Signature verification fails when signing the Body

Hi,

Can you send the client code?

Regards,
Shankar

On Thu, Oct 15, 2009 at 4:38 PM, Doughty, Michael
<Michael_Doughty@...> wrote:


--
S.Uthaiyashankar
Software Architect
WSO2 Inc.
http://wso2.com/ - "The Open Source SOA Company"

Are you asking for the entire MSVC project?  Or are you asking for just the source files?

-----Original Message-----
From: Selvaratnam Uthaiyashankar [mailto:uthaiyashankar@...]
Sent: Thursday, October 15, 2009 10:25 PM
To: Apache AXIS C User List
Subject: Re: Signature verification fails when signing the Body

Hi,

Can you send the client code?

Regards,
Shankar

On Thu, Oct 15, 2009 at 4:38 PM, Doughty, Michael
<Michael_Doughty@...> wrote:


--
S.Uthaiyashankar
Software Architect
WSO2 Inc.
http://wso2.com/ - "The Open Source SOA Company"

I want to run and reproduce the problem. Just the source files are enough.

Regards,
Shankar

On Fri, Oct 16, 2009 at 7:56 PM, Doughty, Michael
<Michael_Doughty@...> wrote:


--
S.Uthaiyashankar
Software Architect
WSO2 Inc.
http://wso2.com/ - "The Open Source SOA Company"

I've attached the main source file.  But if you need the whole MSVC project file, let me know.  I really appreciate your help.

-----Original Message-----
From: Doughty, Michael
Sent: Friday, October 16, 2009 9:27 AM
To: 'Apache AXIS C User List'
Subject: RE: Signature verification fails when signing the Body

Are you asking for the entire MSVC project?  Or are you asking for just the source files?

-----Original Message-----
From: Selvaratnam Uthaiyashankar [mailto:uthaiyashankar@...]
Sent: Thursday, October 15, 2009 10:25 PM
To: Apache AXIS C User List
Subject: Re: Signature verification fails when signing the Body

Hi,

Can you send the client code?

Regards,
Shankar

On Thu, Oct 15, 2009 at 4:38 PM, Doughty, Michael
<Michael_Doughty@...> wrote:

--
S.Uthaiyashankar
Software Architect
WSO2 Inc.
http://wso2.com/ - "The Open Source SOA Company"

      /**
       * axis2_stub_atrium_classes.c
       *
       * This file was auto-generated from WSDL for "atrium_classes|http://atrium.bmc.com/2009/01/classes" service
       * by the Apache Axis2/Java version: 1.4.1  Built on : Aug 13, 2008 (05:03:35 LKT)
       */

      #include "axis2_stub_atrium_classes.h"
      #include <axis2_msg.h>
          #include "neethi_util.h"     // Alex
          #include <rampart_config.h>  // Alex


      /**
       * axis2_stub_atrium_classes C implementation
       */

      axis2_stub_t*
      axis2_stub_create_atrium_classes(const axutil_env_t *env,
                                      axis2_char_t *client_home,
                                      axis2_char_t *endpoint_uri)
      {
         axis2_stub_t *stub = NULL;
         axis2_endpoint_ref_t *endpoint_ref = NULL;
         AXIS2_FUNC_PARAM_CHECK (client_home, env, NULL)

         if (NULL == endpoint_uri)
         {
            endpoint_uri = axis2_stub_get_endpoint_uri_of_atrium_classes(env);
         }

         endpoint_ref = axis2_endpoint_ref_create(env, endpoint_uri);

         stub = axis2_stub_create_with_endpoint_ref_and_client_home (env, endpoint_ref, client_home);

         if (NULL == stub)
         {
            if(NULL != endpoint_ref)
            {
                axis2_endpoint_ref_free(endpoint_ref, env);
            }
            return NULL;
         }


         axis2_stub_populate_services_for_atrium_classes(stub, env);
         return stub;
      }


      void
      axis2_stub_populate_services_for_atrium_classes(axis2_stub_t *stub, const axutil_env_t *env)
      {
         axis2_svc_client_t *svc_client = NULL;
         axutil_qname_t *svc_qname =  NULL;
         axutil_qname_t *op_qname =  NULL;
         axis2_svc_t *svc = NULL;
         axis2_op_t *op = NULL;
         axis2_op_t *annon_op = NULL;
         axis2_msg_t *msg_out = NULL;
         axis2_msg_t *msg_in = NULL;
         axis2_msg_t *msg_out_fault = NULL;
         axis2_msg_t *msg_in_fault = NULL;


         /* Modifying the Service */
         svc_client = axis2_stub_get_svc_client (stub, env );
         svc = (axis2_svc_t*)axis2_svc_client_get_svc( svc_client, env );

         annon_op = axis2_svc_get_op_with_name(svc, env, AXIS2_ANON_OUT_IN_OP);
         msg_out = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT);
         msg_in = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN);
         msg_out_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT_FAULT);
         msg_in_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN_FAULT);

         svc_qname = axutil_qname_create(env,"atrium_classes" ,NULL, NULL);
         axis2_svc_set_qname (svc, env, svc_qname);

         /* creating the operations*/

         
           op_qname = axutil_qname_create(env,
                                         "CreateAttribute" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "SetAttribute" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "SetClass" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "CreateClass" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "DeleteAttribute" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "ListClasses" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "GetAttributes" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "DeleteClass" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
           op_qname = axutil_qname_create(env,
                                         "GetClass" ,
                                         "http://atrium.bmc.com/2009/01/classes",
                                         NULL);
           op = axis2_op_create_with_qname(env, op_qname);
           
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
             
           axis2_msg_increment_ref(msg_out, env);
           axis2_msg_increment_ref(msg_in, env);
           axis2_msg_increment_ref(msg_out_fault, env);
           axis2_msg_increment_ref(msg_in_fault, env);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
           axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
           axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
           
           axis2_svc_add_op(svc, env, op);

         
      }

      /**
       *return end point picked from wsdl
       */
      axis2_char_t*
      axis2_stub_get_endpoint_uri_of_atrium_classes( const axutil_env_t *env )
      {
        axis2_char_t *endpoint_uri = NULL;
        /* set the address from here */
       
              endpoint_uri = "http://w23e-mv-cdb-vm2:9090/atriumclasses_porttype";
           
        return endpoint_uri;
      }


 
         /**
          * auto generated method signature
          * for "CreateAttribute|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _createAttribute
          *
          * @return adb_StatusOutput_t*
          */
         adb_StatusOutput_t*
         axis2_stub_op_atrium_classes_CreateAttribute( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_CreateAttribute_t* _createAttribute)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_StatusOutput_t* ret_val = NULL;
           
                       payload = adb_CreateAttribute_serialize(_createAttribute, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "CreateAttribute";
             
              soap_act = axutil_string_create(env, "CreateAttribute");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_StatusOutput_create(env);

                    if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_StatusOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StatusOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "SetAttribute|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _setAttribute
          *
          * @return adb_StatusOutput_t*
          */
         adb_StatusOutput_t*
         axis2_stub_op_atrium_classes_SetAttribute( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_SetAttribute_t* _setAttribute)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_StatusOutput_t* ret_val = NULL;
           
                       payload = adb_SetAttribute_serialize(_setAttribute, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "SetAttribute";
             
              soap_act = axutil_string_create(env, "SetAttribute");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_StatusOutput_create(env);

                    if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_StatusOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StatusOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "SetClass|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _setClass
          *
          * @return adb_StatusOutput_t*
          */
         adb_StatusOutput_t*
         axis2_stub_op_atrium_classes_SetClass( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_SetClass_t* _setClass)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_StatusOutput_t* ret_val = NULL;
           
                       payload = adb_SetClass_serialize(_setClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "SetClass";
             
              soap_act = axutil_string_create(env, "SetClass");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_StatusOutput_create(env);

                    if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_StatusOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StatusOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "CreateClass|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _createClass
          *
          * @return adb_StatusOutput_t*
          */
         adb_StatusOutput_t*
         axis2_stub_op_atrium_classes_CreateClass( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_CreateClass_t* _createClass)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_StatusOutput_t* ret_val = NULL;
           
                       payload = adb_CreateClass_serialize(_createClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "CreateClass";
             
              soap_act = axutil_string_create(env, "CreateClass");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_StatusOutput_create(env);

                    if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_StatusOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StatusOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "DeleteAttribute|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _deleteAttribute
          *
          * @return adb_StatusOutput_t*
          */
         adb_StatusOutput_t*
         axis2_stub_op_atrium_classes_DeleteAttribute( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_DeleteAttribute_t* _deleteAttribute)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_StatusOutput_t* ret_val = NULL;
           
                       payload = adb_DeleteAttribute_serialize(_deleteAttribute, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "DeleteAttribute";
             
              soap_act = axutil_string_create(env, "DeleteAttribute");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_StatusOutput_create(env);

                    if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_StatusOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StatusOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "ListClasses|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _listClasses
          *
          * @return adb_ListClassesOutput_t*
          */
         adb_ListClassesOutput_t*
         axis2_stub_op_atrium_classes_ListClasses( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_ListClasses_t* _listClasses)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;
                        axis2_status_t     status;              // Alex
                        const axis2_char_t *client_home = NULL; // Alex
                        rampart_config_t* client_config = NULL; // Alex
                        axutil_property_t *property1 = NULL;     // Alex

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_ListClassesOutput_t* ret_val = NULL;
           
                        //Alex
                        axis2_char_t *file_name = "policy.xml";
                        axis2_char_t policy_file[300];
                        neethi_policy_t *policy = NULL;
                        //Alex

                        //Alex
                        client_home = AXIS2_GETENV("AXIS2C_HOME");
                        if (!client_home) {
                                printf("Environment varaible AXIS2C_HOME is missing. Exiting...\n");
                                return(0);
                        }

                        //Alex


            payload = adb_ListClasses_serialize(_listClasses, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
            // Alex
            // Alex: Read policy.xml file here !
                        sprintf(policy_file, "%s/%s", client_home, file_name);
                        printf("policy file=%s\n", policy_file);
                        policy = neethi_util_create_policy_from_file(env, policy_file);
                        if(!policy)
                        {
                                printf("neethi_util_create_policy_from_file %s has failed\n",
                                           policy_file);
                                return NULL;
                        }

                        status = axis2_svc_client_set_policy(svc_client, env, policy);
                        if(status != AXIS2_SUCCESS)
                        {
                                printf("axis2_svc_client_set_policy has failed\n");
                                return NULL;
                        }
            // Alex
                       
            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }

            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "ListClasses";
             
              soap_act = axutil_string_create(env, "ListClasses");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );

            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);

            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_ListClassesOutput_create(env);

                    if(adb_ListClassesOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_ListClassesOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ListClassesOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }

                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "GetAttributes|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _getAttributes
          *
          * @return adb_GetAttributesOutput_t*
          */
         adb_GetAttributesOutput_t*
         axis2_stub_op_atrium_classes_GetAttributes( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_GetAttributes_t* _getAttributes)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_GetAttributesOutput_t* ret_val = NULL;
           
                       payload = adb_GetAttributes_serialize(_getAttributes, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "GetAttributes";
             
              soap_act = axutil_string_create(env, "GetAttributes");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_GetAttributesOutput_create(env);

                    if(adb_GetAttributesOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_GetAttributesOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the GetAttributesOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "DeleteClass|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _deleteClass
          *
          * @return adb_StatusOutput_t*
          */
         adb_StatusOutput_t*
         axis2_stub_op_atrium_classes_DeleteClass( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_DeleteClass_t* _deleteClass)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_StatusOutput_t* ret_val = NULL;
           
                       payload = adb_DeleteClass_serialize(_deleteClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "DeleteClass";
             
              soap_act = axutil_string_create(env, "DeleteClass");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_StatusOutput_create(env);

                    if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_StatusOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StatusOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       
         /**
          * auto generated method signature
          * for "GetClass|http://atrium.bmc.com/2009/01/classes" operation.
          *
          * @param _getClass
          *
          * @return adb_GetClassOutput_t*
          */
         adb_GetClassOutput_t*
         axis2_stub_op_atrium_classes_GetClass( axis2_stub_t *stub, const axutil_env_t *env,
                                              adb_GetClass_t* _getClass)
         {
            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;
            axiom_node_t *ret_node = NULL;

            const axis2_char_t *soap_action = NULL;
            axutil_qname_t *op_qname =  NULL;
            axiom_node_t *payload = NULL;
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
            adb_GetClassOutput_t* ret_val = NULL;
           
                       payload = adb_GetClass_serialize(_getClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   
            svc_client = axis2_stub_get_svc_client(stub, env );
           
           
           
           

            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
                return NULL;
            }
            soap_action = axis2_options_get_action( options, env );
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "GetClass";
             
              soap_act = axutil_string_create(env, "GetClass");
              axis2_options_set_soap_action(options, env, soap_act);    
             
              axis2_options_set_action( options, env, soap_action );
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
           
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);    
             
              axis2_options_set_action( options, env, NULL);
            }

           
           
                    if ( NULL == ret_node )
                    {
                        return NULL;
                    }
                    ret_val = adb_GetClassOutput_create(env);

                    if(adb_GetClassOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                    {
                        if(ret_val != NULL)
                        {
                            adb_GetClassOutput_free(ret_val, env);
                        }

                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the GetClassOutput_deserialize: "
                                                                "This should be due to an invalid XML");
                        return NULL;
                    }
                    return ret_val;
               
        }
       

        struct axis2_stub_atrium_classes_CreateAttribute_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_CreateAttribute(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_CreateAttribute_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_CreateAttribute_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_CreateAttribute(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput, void *data);
            struct axis2_stub_atrium_classes_CreateAttribute_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_StatusOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_CreateAttribute_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_StatusOutput_create(env);
     
                        if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_StatusOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "CreateAttribute|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _createAttribute
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_CreateAttribute( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_CreateAttribute_t* _createAttribute,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_CreateAttribute_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_CreateAttribute_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_CreateAttribute_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_CreateAttribute_serialize(_createAttribute, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "CreateAttribute";
             
              soap_act = axutil_string_create(env, "CreateAttribute");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_CreateAttribute);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_CreateAttribute);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_SetAttribute_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput0, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_SetAttribute(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_SetAttribute_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_SetAttribute_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_SetAttribute(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput0, void *data);
            struct axis2_stub_atrium_classes_SetAttribute_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_StatusOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_SetAttribute_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_StatusOutput_create(env);
     
                        if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_StatusOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "SetAttribute|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _setAttribute
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_SetAttribute( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_SetAttribute_t* _setAttribute,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput0, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_SetAttribute_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_SetAttribute_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_SetAttribute_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_SetAttribute_serialize(_setAttribute, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "SetAttribute";
             
              soap_act = axutil_string_create(env, "SetAttribute");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_SetAttribute);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_SetAttribute);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_SetClass_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput1, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_SetClass(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_SetClass_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_SetClass_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_SetClass(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput1, void *data);
            struct axis2_stub_atrium_classes_SetClass_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_StatusOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_SetClass_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_StatusOutput_create(env);
     
                        if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_StatusOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "SetClass|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _setClass
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_SetClass( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_SetClass_t* _setClass,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput1, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_SetClass_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_SetClass_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_SetClass_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_SetClass_serialize(_setClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "SetClass";
             
              soap_act = axutil_string_create(env, "SetClass");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_SetClass);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_SetClass);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_CreateClass_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput2, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_CreateClass(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_CreateClass_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_CreateClass_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_CreateClass(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput2, void *data);
            struct axis2_stub_atrium_classes_CreateClass_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_StatusOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_CreateClass_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_StatusOutput_create(env);
     
                        if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_StatusOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "CreateClass|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _createClass
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_CreateClass( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_CreateClass_t* _createClass,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput2, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_CreateClass_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_CreateClass_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_CreateClass_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_CreateClass_serialize(_createClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "CreateClass";
             
              soap_act = axutil_string_create(env, "CreateClass");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_CreateClass);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_CreateClass);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_DeleteAttribute_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput3, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_DeleteAttribute(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_DeleteAttribute_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_DeleteAttribute_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_DeleteAttribute(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput3, void *data);
            struct axis2_stub_atrium_classes_DeleteAttribute_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_StatusOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_DeleteAttribute_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_StatusOutput_create(env);
     
                        if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_StatusOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "DeleteAttribute|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _deleteAttribute
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_DeleteAttribute( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_DeleteAttribute_t* _deleteAttribute,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput3, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_DeleteAttribute_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_DeleteAttribute_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_DeleteAttribute_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_DeleteAttribute_serialize(_deleteAttribute, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "DeleteAttribute";
             
              soap_act = axutil_string_create(env, "DeleteAttribute");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_DeleteAttribute);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_DeleteAttribute);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_ListClasses_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ListClassesOutput_t* _listClassesOutput, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_ListClasses(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_ListClasses_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_ListClasses_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_ListClasses(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ListClassesOutput_t* _listClassesOutput, void *data);
            struct axis2_stub_atrium_classes_ListClasses_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_ListClassesOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_ListClasses_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_ListClassesOutput_create(env);
     
                        if(adb_ListClassesOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_ListClassesOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "ListClasses|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _listClasses
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_ListClasses( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_ListClasses_t* _listClasses,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ListClassesOutput_t* _listClassesOutput, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_ListClasses_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_ListClasses_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_ListClasses_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_ListClasses_serialize(_listClasses, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "ListClasses";
             
              soap_act = axutil_string_create(env, "ListClasses");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_ListClasses);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_ListClasses);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_GetAttributes_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetAttributesOutput_t* _getAttributesOutput, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_GetAttributes(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_GetAttributes_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_GetAttributes_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_GetAttributes(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetAttributesOutput_t* _getAttributesOutput, void *data);
            struct axis2_stub_atrium_classes_GetAttributes_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_GetAttributesOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_GetAttributes_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_GetAttributesOutput_create(env);
     
                        if(adb_GetAttributesOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_GetAttributesOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "GetAttributes|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _getAttributes
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_GetAttributes( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_GetAttributes_t* _getAttributes,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetAttributesOutput_t* _getAttributesOutput, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_GetAttributes_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_GetAttributes_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_GetAttributes_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_GetAttributes_serialize(_getAttributes, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "GetAttributes";
             
              soap_act = axutil_string_create(env, "GetAttributes");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_GetAttributes);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_GetAttributes);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_DeleteClass_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput4, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_DeleteClass(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_DeleteClass_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_DeleteClass_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_DeleteClass(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput4, void *data);
            struct axis2_stub_atrium_classes_DeleteClass_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_StatusOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_DeleteClass_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_StatusOutput_create(env);
     
                        if(adb_StatusOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_StatusOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "DeleteClass|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _deleteClass
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_DeleteClass( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_DeleteClass_t* _deleteClass,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StatusOutput_t* _statusOutput4, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_DeleteClass_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_DeleteClass_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_DeleteClass_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_DeleteClass_serialize(_deleteClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "DeleteClass";
             
              soap_act = axutil_string_create(env, "DeleteClass");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_DeleteClass);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_DeleteClass);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

         

        struct axis2_stub_atrium_classes_GetClass_callback_data
        {  
            void *data;
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetClassOutput_t* _getClassOutput, void *data);
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
        };

        static axis2_status_t AXIS2_CALL axis2_stub_on_error_atrium_classes_GetClass(axis2_callback_t *callback, const axutil_env_t *env, int exception)
        {
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
            struct axis2_stub_atrium_classes_GetClass_callback_data* callback_data = NULL;
            void *user_data = NULL;

            axis2_status_t status;
       
            callback_data = (struct axis2_stub_atrium_classes_GetClass_callback_data*)axis2_callback_get_data(callback);
       
            user_data = callback_data->data;
            on_error = callback_data->on_error;
       
            status = on_error(env, exception, user_data);

            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        axis2_status_t AXIS2_CALL axis2_stub_on_complete_atrium_classes_GetClass(axis2_callback_t *callback, const axutil_env_t *env)
        {
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetClassOutput_t* _getClassOutput, void *data);
            struct axis2_stub_atrium_classes_GetClass_callback_data* callback_data = NULL;
            void *user_data = NULL;
            axis2_status_t status = AXIS2_SUCCESS;
 
            adb_GetClassOutput_t* ret_val = NULL;
           

            axiom_node_t *ret_node = NULL;
            axiom_soap_envelope_t *soap_envelope = NULL;

           

            callback_data = (struct axis2_stub_atrium_classes_GetClass_callback_data*)axis2_callback_get_data(callback);

            soap_envelope = axis2_callback_get_envelope(callback, env);
            if(soap_envelope)
            {
                axiom_soap_body_t *soap_body;
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
                if(soap_body)
                {
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
                    if(body_node)
                    {
                        ret_node = axiom_node_get_first_child(body_node, env);
                    }
                }
               
               
            }

            user_data = callback_data->data;
            on_complete = callback_data->on_complete;

           
                    if(ret_node != NULL)
                    {
                        ret_val = adb_GetClassOutput_create(env);
     
                        if(adb_GetClassOutput_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
                        {
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
                                                                    "This should be due to an invalid XML");
                            adb_GetClassOutput_free(ret_val, env);
                            ret_val = NULL;
                        }
                     }
                     else
                     {
                         ret_val = NULL;
                     }
                     status = on_complete(env, ret_val, user_data);
               
 
            if(callback_data)
            {
                AXIS2_FREE(env->allocator, callback_data);
            }
            return status;
        }

        /**
          * auto generated method signature for asynchronous invocations
          * for "GetClass|http://atrium.bmc.com/2009/01/classes" operation.
         
          *
          * @param _getClass
          * @param on_complete callback to handle on complete
          * @param on_error callback to handle on error
          */
         void axis2_stub_start_op_atrium_classes_GetClass( axis2_stub_t *stub, const axutil_env_t *env,
                                                    adb_GetClass_t* _getClass,
                                                  void *user_data,
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetClassOutput_t* _getClassOutput, void *data) ,
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
         {

            axis2_callback_t *callback = NULL;

            axis2_svc_client_t *svc_client = NULL;
            axis2_options_t *options = NULL;

            const axis2_char_t *soap_action = NULL;
            axiom_node_t *payload = NULL;

            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
           
            axutil_string_t *soap_act = NULL;
           
           
            struct axis2_stub_atrium_classes_GetClass_callback_data *callback_data;

            callback_data = (struct axis2_stub_atrium_classes_GetClass_callback_data*) AXIS2_MALLOC(env->allocator,
                                    sizeof(struct axis2_stub_atrium_classes_GetClass_callback_data));
            if(NULL == callback_data)
            {
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
                return;
            }
           
           
                       payload = adb_GetClass_serialize(_getClass, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
                   



            options = axis2_stub_get_options( stub, env);
            if (NULL == options)
            {
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
              return;
            }
            svc_client = axis2_stub_get_svc_client (stub, env);
            soap_action =axis2_options_get_action (options, env);
            if (NULL == soap_action)
            {
              is_soap_act_set = AXIS2_FALSE;
              soap_action = "GetClass";
             
              soap_act = axutil_string_create(env, "GetClass");
              axis2_options_set_soap_action(options, env, soap_act);
             
              axis2_options_set_action( options, env, soap_action);
            }
           
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
             

            callback = axis2_callback_create(env);
            /* Set our on_complete fucntion pointer to the callback object */
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_atrium_classes_GetClass);
            /* Set our on_error function pointer to the callback object */
            axis2_callback_set_on_error(callback, axis2_stub_on_error_atrium_classes_GetClass);

            callback_data-> data = user_data;
            callback_data-> on_complete = on_complete;
            callback_data-> on_error = on_error;

            axis2_callback_set_data(callback, (void*)callback_data);

            /* Send request */
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
           
            if (!is_soap_act_set)
            {
             
              axis2_options_set_soap_action(options, env, NULL);
             
              axis2_options_set_action(options, env, NULL);
            }
         }

           


     /**
      * function to free any soap input headers
      */
     


     /**
      * function to free any soap output headers
      */