axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From shan...@apache.org
Subject svn commit: r805347 [13/31] - in /webservices/axis2/trunk/c/src: core/addr/ core/clientapi/ core/context/ core/deployment/ core/description/ core/engine/ core/phaseresolver/ core/receivers/ core/transport/amqp/receiver/ core/transport/amqp/receiver/qpi...
Date Tue, 18 Aug 2009 10:15:53 GMT
Modified: webservices/axis2/trunk/c/src/core/engine/engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/engine/engine.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/engine/engine.c (original)
+++ webservices/axis2/trunk/c/src/core/engine/engine.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -31,16 +30,16 @@
 
 struct axis2_engine
 {
-
     /** Configuration context */
     axis2_conf_ctx_t *conf_ctx;
 };
 
-axis2_status_t axis2_engine_check_must_understand_headers(
+axis2_status_t
+axis2_engine_check_must_understand_headers(
     const axutil_env_t * env,
     axis2_msg_ctx_t * msg_ctx);
 
-AXIS2_EXTERN axis2_engine_t *AXIS2_CALL
+AXIS2_EXTERN axis2_engine_t * AXIS2_CALL
 axis2_engine_create(
     const axutil_env_t * env,
     axis2_conf_ctx_t * conf_ctx)
@@ -50,7 +49,7 @@
     AXIS2_ENV_CHECK(env, NULL);
 
     engine = AXIS2_MALLOC(env->allocator, sizeof(axis2_engine_t));
-    if (!engine)
+    if(!engine)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
@@ -59,7 +58,7 @@
 
     engine->conf_ctx = NULL;
 
-    if (conf_ctx)
+    if(conf_ctx)
     {
         engine->conf_ctx = conf_ctx;
     }
@@ -94,42 +93,38 @@
 
     /* Find and invoke the phases */
     op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-    if (op_ctx)
+    if(op_ctx)
     {
         axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env);
-        if (op)
+        if(op)
         {
             phases = axis2_op_get_out_flow(op, env);
         }
     }
 
-    if (axis2_msg_ctx_is_paused(msg_ctx, env))
+    if(axis2_msg_ctx_is_paused(msg_ctx, env))
     {
         /* Message has paused, so rerun it from the position it stopped.
-           The handler which paused the message will be the first one to resume 
-           invocation
+         The handler which paused the message will be the first one to resume
+         invocation
          */
-        status =
-            axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
-        if (status != AXIS2_SUCCESS)
+        status = axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
+        if(status != AXIS2_SUCCESS)
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Resuming invocation of phases failed");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Resuming invocation of phases failed");
             return status;
         }
 
         conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-        if (conf_ctx)
+        if(conf_ctx)
         {
             conf = axis2_conf_ctx_get_conf(conf_ctx, env);
-            if (conf)
+            if(conf)
             {
-                axutil_array_list_t *global_out_phase =
-                    axis2_conf_get_out_phases(conf, env);
-                if (global_out_phase)
+                axutil_array_list_t *global_out_phase = axis2_conf_get_out_phases(conf, env);
+                if(global_out_phase)
                 {
-                    axis2_engine_invoke_phases(engine, env, global_out_phase,
-                                               msg_ctx);
+                    axis2_engine_invoke_phases(engine, env, global_out_phase, msg_ctx);
                 }
             }
         }
@@ -137,60 +132,54 @@
     else
     {
         status = axis2_engine_invoke_phases(engine, env, phases, msg_ctx);
-        if (status != AXIS2_SUCCESS)
+        if(status != AXIS2_SUCCESS)
         {
             return status;
         }
 
         conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-        if (conf_ctx)
+        if(conf_ctx)
         {
             conf = axis2_conf_ctx_get_conf(conf_ctx, env);
-            if (conf)
+            if(conf)
             {
-                axutil_array_list_t *global_out_phase =
-                    axis2_conf_get_out_phases(conf, env);
-                if (global_out_phase)
+                axutil_array_list_t *global_out_phase = axis2_conf_get_out_phases(conf, env);
+                if(global_out_phase)
                 {
-                    axis2_engine_invoke_phases(engine, env, global_out_phase,
-                                               msg_ctx);
+                    axis2_engine_invoke_phases(engine, env, global_out_phase, msg_ctx);
                 }
             }
         }
     }
 
-    if (!(axis2_msg_ctx_is_paused(msg_ctx, env)))
+    if(!(axis2_msg_ctx_is_paused(msg_ctx, env)))
     {
         /* Write the message to wire */
         axis2_transport_sender_t *transport_sender = NULL;
-        axis2_transport_out_desc_t *transport_out =
-            axis2_msg_ctx_get_transport_out_desc(msg_ctx, env);
+        axis2_transport_out_desc_t *transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx,
+            env);
 
-        if (transport_out)
+        if(transport_out)
         {
-            transport_sender =
-                axis2_transport_out_desc_get_sender(transport_out, env);
-            if (!transport_sender)
+            transport_sender = axis2_transport_out_desc_get_sender(transport_out, env);
+            if(!transport_sender)
                 return AXIS2_FAILURE;
 
             status = AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx);
-            if (status != AXIS2_SUCCESS)
+            if(status != AXIS2_SUCCESS)
             {
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                    "Transport sender invoke failed");
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport sender invoke failed");
                 return status;
             }
         }
         else
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
-                            "Transport out is not set in message context");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out is not set in message
context");
             return AXIS2_FAILURE;
         }
     }
 
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
-                    "axis2_engine_send end successfully");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send end successfully");
     return AXIS2_SUCCESS;
 }
 
@@ -215,15 +204,13 @@
 
     conf = axis2_conf_ctx_get_conf(conf_ctx, env);
 
-    pre_calculated_phases =
-        axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env);
+    pre_calculated_phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf,
env);
 
-    if (axis2_msg_ctx_is_paused(msg_ctx, env))
+    if(axis2_msg_ctx_is_paused(msg_ctx, env))
     {
         /* The message has paused, so re-run them from the position they stopped. */
-        axis2_engine_resume_invocation_phases(engine, env,
-                                              pre_calculated_phases, msg_ctx);
-        if (axis2_msg_ctx_is_paused(msg_ctx, env))
+        axis2_engine_resume_invocation_phases(engine, env, pre_calculated_phases, msg_ctx);
+        if(axis2_msg_ctx_is_paused(msg_ctx, env))
         {
             AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return
here.");
             return AXIS2_SUCCESS;
@@ -231,93 +218,87 @@
 
         /* Resume op specific phases */
         op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-        if (op_ctx)
+        if(op_ctx)
         {
             op = axis2_op_ctx_get_op(op_ctx, env);
             op_specific_phases = axis2_op_get_in_flow(op, env);
-            axis2_engine_resume_invocation_phases(engine, env,
-                                                  op_specific_phases, msg_ctx);
-            if (axis2_msg_ctx_is_paused(msg_ctx, env))
+            axis2_engine_resume_invocation_phases(engine, env, op_specific_phases, msg_ctx);
+            if(axis2_msg_ctx_is_paused(msg_ctx, env))
             {
-                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So
return here.");
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                    "Message context is paused. So return here.");
                 return AXIS2_SUCCESS;
             }
         }
     }
     else
     {
-        status = axis2_engine_invoke_phases(engine, env,
-                                            pre_calculated_phases, msg_ctx);
-        if (status != AXIS2_SUCCESS)
+        status = axis2_engine_invoke_phases(engine, env, pre_calculated_phases, msg_ctx);
+        if(status != AXIS2_SUCCESS)
         {
-            if (axis2_msg_ctx_get_server_side(msg_ctx, env))
+            if(axis2_msg_ctx_get_server_side(msg_ctx, env))
             {
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                    "Invoking pre-calculated phases failed");
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking pre-calculated phases
failed");
                 return status;
             }
         }
 
-        if (axis2_msg_ctx_is_paused(msg_ctx, env))
+        if(axis2_msg_ctx_is_paused(msg_ctx, env))
         {
             AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return
here.");
             return AXIS2_SUCCESS;
         }
 
         op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-        if (op_ctx)
+        if(op_ctx)
         {
             op = axis2_op_ctx_get_op(op_ctx, env);
             op_specific_phases = axis2_op_get_in_flow(op, env);
-            status = axis2_engine_invoke_phases(engine, env,
-                                                op_specific_phases, msg_ctx);
-            if (status != AXIS2_SUCCESS)
+            status = axis2_engine_invoke_phases(engine, env, op_specific_phases, msg_ctx);
+            if(status != AXIS2_SUCCESS)
             {
                 axis2_char_t *op_name = NULL;
-                op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), 
-                    env);
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
+                op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                     "Invoking operation specific phases failed for operation %s", op_name);
                 return status;
             }
 
-            if (axis2_msg_ctx_is_paused(msg_ctx, env))
+            if(axis2_msg_ctx_is_paused(msg_ctx, env))
             {
-                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So
return here.");
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                    "Message context is paused. So return here.");
                 return AXIS2_SUCCESS;
             }
         }
     }
 
-    if ((axis2_msg_ctx_get_server_side(msg_ctx, env)) &&
-        !(axis2_msg_ctx_is_paused(msg_ctx, env)))
+    if((axis2_msg_ctx_get_server_side(msg_ctx, env)) && !(axis2_msg_ctx_is_paused(msg_ctx,
env)))
     {
         axis2_msg_recv_t *receiver = NULL;
 
         status = axis2_engine_check_must_understand_headers(env, msg_ctx);
-        if (status != AXIS2_SUCCESS)
+        if(status != AXIS2_SUCCESS)
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Check for must understand headers failed");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Check for must understand headers
failed");
             return status;
         }
 
         /* Invoke the message receivers */
-        if (!op)
+        if(!op)
         {
             AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation not found");
             return AXIS2_FAILURE;
         }
         receiver = axis2_op_get_msg_recv(op, env);
-        if (!receiver)
+        if(!receiver)
         {
             AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
-                            "Message receiver not set in operation description");
+                "Message receiver not set in operation description");
             return AXIS2_FAILURE;
         }
-        status = axis2_msg_recv_receive(receiver, env, msg_ctx,
-                                        axis2_msg_recv_get_derived(receiver,
-                                                                   env));
+        status = axis2_msg_recv_receive(receiver, env, msg_ctx, axis2_msg_recv_get_derived(
+            receiver, env));
     }
 
     AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_receive");
@@ -340,42 +321,39 @@
     AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
 
     op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-    if (op_ctx)
+    if(op_ctx)
     {
         axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env);
-        if (op)
+        if(op)
         {
             phases = axis2_op_get_fault_out_flow(op, env);
         }
     }
 
-    if (axis2_msg_ctx_is_paused(msg_ctx, env))
+    if(axis2_msg_ctx_is_paused(msg_ctx, env))
     {
         /* Message has paused, so rerun it from the position it stopped.
-           The handler which paused the message will be the first one to resume 
-           invocation
+         The handler which paused the message will be the first one to resume
+         invocation
          */
-        status =
-            axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
-        if (status != AXIS2_SUCCESS)
+        status = axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
+        if(status != AXIS2_SUCCESS)
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Resuming invoking the phases failed");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Resuming invoking the phases failed");
             return status;
         }
 
         conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-        if (conf_ctx)
+        if(conf_ctx)
         {
             conf = axis2_conf_ctx_get_conf(conf_ctx, env);
-            if (conf)
+            if(conf)
             {
-                axutil_array_list_t *global_out_fault_phase =
-                    axis2_conf_get_out_fault_flow(conf, env);
-                if (global_out_fault_phase)
+                axutil_array_list_t *global_out_fault_phase = axis2_conf_get_out_fault_flow(conf,
+                    env);
+                if(global_out_fault_phase)
                 {
-                    axis2_engine_invoke_phases(engine, env,
-                                               global_out_fault_phase, msg_ctx);
+                    axis2_engine_invoke_phases(engine, env, global_out_fault_phase, msg_ctx);
                 }
             }
         }
@@ -385,49 +363,45 @@
         status = axis2_engine_invoke_phases(engine, env, phases, msg_ctx);
 
         conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-        if (conf_ctx)
+        if(conf_ctx)
         {
             conf = axis2_conf_ctx_get_conf(conf_ctx, env);
-            if (conf)
+            if(conf)
             {
-                axutil_array_list_t *global_out_fault_phase =
-                    axis2_conf_get_out_fault_flow(conf, env);
-                if (global_out_fault_phase)
+                axutil_array_list_t *global_out_fault_phase = axis2_conf_get_out_fault_flow(conf,
+                    env);
+                if(global_out_fault_phase)
                 {
-                    axis2_engine_invoke_phases(engine, env,
-                                               global_out_fault_phase, msg_ctx);
+                    axis2_engine_invoke_phases(engine, env, global_out_fault_phase, msg_ctx);
                 }
             }
         }
     }
 
-    if (!(axis2_msg_ctx_is_paused(msg_ctx, env)))
+    if(!(axis2_msg_ctx_is_paused(msg_ctx, env)))
     {
         /* Write the message to wire */
         axis2_transport_sender_t *transport_sender = NULL;
-        axis2_transport_out_desc_t *transport_out =
-            axis2_msg_ctx_get_transport_out_desc(msg_ctx, env);
+        axis2_transport_out_desc_t *transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx,
+            env);
 
-        if (transport_out)
+        if(transport_out)
         {
-            transport_sender =
-                axis2_transport_out_desc_get_sender(transport_out, env);
+            transport_sender = axis2_transport_out_desc_get_sender(transport_out, env);
 
-            if (transport_sender)
+            if(transport_sender)
             {
                 AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx);
             }
             else
             {
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                    "Transport sender not found");
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport sender not found");
                 return AXIS2_FAILURE;
             }
         }
         else
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
-                            "Transport out is not set in message context");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out is not set in message
context");
             return AXIS2_FAILURE;
         }
     }
@@ -448,31 +422,27 @@
 
     op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
 
-    if (!op_ctx)
+    if(!op_ctx)
     {
         /* If we do not have an op context that means this may be an incoming
-           dual channel response. So try to dispatch the service */
+         dual channel response. So try to dispatch the service */
         axis2_conf_ctx_t *conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-        if (conf_ctx)
+        if(conf_ctx)
         {
             axis2_conf_t *conf = axis2_conf_ctx_get_conf(conf_ctx, env);
-            if (conf)
+            if(conf)
             {
                 axutil_array_list_t *phases =
-                    axis2_conf_get_in_phases_upto_and_including_post_dispatch
-                    (conf, env);
-                if (phases)
+                    axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env);
+                if(phases)
                 {
-                    if (axis2_msg_ctx_is_paused(msg_ctx, env))
+                    if(axis2_msg_ctx_is_paused(msg_ctx, env))
                     {
-                        axis2_engine_resume_invocation_phases(engine,
-                                                              env, phases,
-                                                              msg_ctx);
+                        axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
                     }
                     else
                     {
-                        axis2_engine_invoke_phases(engine, env, phases,
-                                                   msg_ctx);
+                        axis2_engine_invoke_phases(engine, env, phases, msg_ctx);
                     }
                 }
             }
@@ -481,11 +451,11 @@
 
     op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
     /* Find and execute the fault in flow handlers */
-    if (op_ctx)
+    if(op_ctx)
     {
         axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env);
         axutil_array_list_t *phases = axis2_op_get_fault_in_flow(op, env);
-        if (axis2_msg_ctx_is_paused(msg_ctx, env))
+        if(axis2_msg_ctx_is_paused(msg_ctx, env))
         {
             axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
         }
@@ -498,7 +468,7 @@
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
+AXIS2_EXTERN axis2_msg_ctx_t * AXIS2_CALL
 axis2_engine_create_fault_msg_ctx(
     axis2_engine_t * engine,
     const axutil_env_t * env,
@@ -520,38 +490,32 @@
 
     AXIS2_PARAM_CHECK(env->error, processing_context, NULL);
 
-    if (axis2_msg_ctx_get_process_fault(processing_context, env))
+    if(axis2_msg_ctx_get_process_fault(processing_context, env))
     {
-        AXIS2_ERROR_SET(env->error,
-                        AXIS2_ERROR_INVALID_STATE_PROCESSING_FAULT_ALREADY,
-                        AXIS2_FAILURE);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Creating fault message contex failed");
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PROCESSING_FAULT_ALREADY,
+            AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating fault message contex failed");
         return NULL;
     }
 
-    fault_ctx = axis2_msg_ctx_create(env, engine->conf_ctx,
-                                     axis2_msg_ctx_get_transport_in_desc
-                                     (processing_context, env),
-                                     axis2_msg_ctx_get_transport_out_desc
-                                     (processing_context, env));
+    fault_ctx = axis2_msg_ctx_create(env, engine->conf_ctx, axis2_msg_ctx_get_transport_in_desc(
+        processing_context, env), axis2_msg_ctx_get_transport_out_desc(processing_context,
env));
 
     axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE);
 
     fault_to = axis2_msg_ctx_get_fault_to(processing_context, env);
-    if (fault_to)
+    if(fault_to)
     {
-        const axis2_char_t *address =
-            axis2_endpoint_ref_get_address(fault_to, env);
-        if (!address)
+        const axis2_char_t *address = axis2_endpoint_ref_get_address(fault_to, env);
+        if(!address)
         {
             fault_to = NULL;
         }
-        else if (axutil_strcmp(AXIS2_WSA_NONE_URL, address) == 0 ||
-                 axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, address) == 0)
+        else if(axutil_strcmp(AXIS2_WSA_NONE_URL, address) == 0 || axutil_strcmp(
+            AXIS2_WSA_NONE_URL_SUBMISSION, address) == 0)
         {
             reply_to = axis2_msg_ctx_get_reply_to(processing_context, env);
-            if (reply_to)
+            if(reply_to)
             {
                 axis2_msg_ctx_set_fault_to(fault_ctx, env, reply_to);
             }
@@ -569,32 +533,29 @@
 
     stream = axis2_msg_ctx_get_transport_out_stream(processing_context, env);
 
-    if (stream)
+    if(stream)
     {
         axis2_msg_ctx_set_transport_out_stream(fault_ctx, env, stream);
     }
 
-    if (!fault_to && !stream)
+    if(!fault_to && !stream)
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT,
-                        AXIS2_FAILURE);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Soap fault target destination not found");
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap fault target destination not found");
         return NULL;
     }
 
     /* Set WSA action */
-    msg_info_headers =
-        axis2_msg_ctx_get_msg_info_headers(processing_context, env);
-    if (msg_info_headers)
+    msg_info_headers = axis2_msg_ctx_get_msg_info_headers(processing_context, env);
+    if(msg_info_headers)
     {
         wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env);
-        if (wsa_action)
+        if(wsa_action)
         {
             /*
-               We have to use the action set by user, 
-               cannot use the default always.
-               wsa_action = "http://www.w3.org/2005/08/addressing/fault"; */
+             We have to use the action set by user,
+             cannot use the default always.
+             wsa_action = "http://www.w3.org/2005/08/addressing/fault"; */
             axis2_msg_ctx_set_wsa_action(fault_ctx, env, wsa_action);
         }
     }
@@ -603,66 +564,53 @@
     msg_id = axis2_msg_ctx_get_msg_id(processing_context, env);
 
     /* we can create with default Relates to namespace. 
-    Actual namespace based on addressing version will be created in addressing out handler
*/
+     Actual namespace based on addressing version will be created in addressing out handler
*/
     relates_to = axis2_relates_to_create(env, msg_id,
-                                         AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE);
+        AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE);
     axis2_msg_ctx_set_relates_to(fault_ctx, env, relates_to);
 
     /* Set msg id */
     msg_uuid = axutil_uuid_gen(env);
     axis2_msg_ctx_set_message_id(fault_ctx, env, msg_uuid);
-    if (msg_uuid)
+    if(msg_uuid)
     {
         AXIS2_FREE(env->allocator, msg_uuid);
         msg_uuid = NULL;
     }
 
-    axis2_msg_ctx_set_op_ctx(fault_ctx, env,
-                             axis2_msg_ctx_get_op_ctx(processing_context, env));
+    axis2_msg_ctx_set_op_ctx(fault_ctx, env, axis2_msg_ctx_get_op_ctx(processing_context,
env));
     axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE);
     axis2_msg_ctx_set_server_side(fault_ctx, env, AXIS2_TRUE);
 
     envelope = axis2_msg_ctx_get_fault_soap_envelope(processing_context, env);
 
-    if (!envelope)
+    if(!envelope)
     {
-        if (axis2_msg_ctx_get_is_soap_11(processing_context, env))
+        if(axis2_msg_ctx_get_is_soap_11(processing_context, env))
         {
-            envelope =
-                axiom_soap_envelope_create_default_soap_fault_envelope(env,
-                                                                       code_value,
-                                                                       reason_text,
-                                                                       AXIOM_SOAP11,
-                                                                       NULL,
-                                                                       NULL);
+            envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value,
+                reason_text, AXIOM_SOAP11, NULL, NULL);
 
         }
         else
         {
-            envelope =
-                axiom_soap_envelope_create_default_soap_fault_envelope(env,
-                                                                       code_value,
-                                                                       reason_text,
-                                                                       AXIOM_SOAP12,
-                                                                       NULL,
-                                                                       NULL);
+            envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value,
+                reason_text, AXIOM_SOAP12, NULL, NULL);
         }
 
-        if (!envelope)
+        if(!envelope)
         {
-            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-                "Creating default soap envelope failed");
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Creating default soap envelope failed");
             return NULL;
         }
     }
 
-    doing_rest = axis2_msg_ctx_get_doing_rest (processing_context, env);
-    axis2_msg_ctx_set_doing_rest (fault_ctx, env, doing_rest);
+    doing_rest = axis2_msg_ctx_get_doing_rest(processing_context, env);
+    axis2_msg_ctx_set_doing_rest(fault_ctx, env, doing_rest);
 
     axis2_msg_ctx_set_soap_envelope(fault_ctx, env, envelope);
-    axis2_msg_ctx_set_out_transport_info(fault_ctx, env,
-                                         axis2_msg_ctx_get_out_transport_info
-                                         (processing_context, env));
+    axis2_msg_ctx_set_out_transport_info(fault_ctx, env, axis2_msg_ctx_get_out_transport_info(
+        processing_context, env));
     return fault_ctx;
 }
 
@@ -681,20 +629,18 @@
     AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
 
-    if (phases)
+    if(phases)
         count = axutil_array_list_size(phases, env);
-    for (i = 0; (i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env))); i++)
+    for(i = 0; (i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env))); i++)
     {
-        axis2_phase_t *phase = (axis2_phase_t *)
-            axutil_array_list_get(phases, env, i);
+        axis2_phase_t *phase = (axis2_phase_t *)axutil_array_list_get(phases, env, i);
 
         status = axis2_phase_invoke(phase, env, msg_ctx);
 
-        if (status != AXIS2_SUCCESS)
+        if(status != AXIS2_SUCCESS)
         {
             const axis2_char_t *phase_name = axis2_phase_get_name(phase, env);
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking phase %s failed", 
-                phase_name);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking phase %s failed", phase_name);
             return status;
         }
     }
@@ -713,8 +659,7 @@
     int count = 0;
     axis2_bool_t found_match = AXIS2_FALSE;
 
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
-                    "Start:axis2_engine_resume_invocation_phases");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_invocation_phases");
     AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
 
@@ -722,50 +667,44 @@
 
     count = axutil_array_list_size(phases, env);
 
-    for (i = 0; i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env)); i++)
+    for(i = 0; i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env)); i++)
     {
-        axis2_phase_t *phase = (axis2_phase_t *) axutil_array_list_get(phases,
-                                                                       env, i);
+        axis2_phase_t *phase = (axis2_phase_t *)axutil_array_list_get(phases, env, i);
         const axis2_char_t *phase_name = axis2_phase_get_name(phase, env);
-        const axis2_char_t *paused_phase_name =
-            axis2_msg_ctx_get_paused_phase_name(msg_ctx, env);
+        const axis2_char_t *paused_phase_name = axis2_msg_ctx_get_paused_phase_name(msg_ctx,
env);
         /* Skip invoking handlers until we find the paused phase */
-        if (phase_name && paused_phase_name && 0 ==
-            axutil_strcmp(phase_name, paused_phase_name))
+        if(phase_name && paused_phase_name && 0 == axutil_strcmp(phase_name,
paused_phase_name))
         {
             int paused_handler_i = -1;
             found_match = AXIS2_TRUE;
 
-            paused_handler_i = axis2_msg_ctx_get_current_handler_index(msg_ctx,
-                                                                       env);
+            paused_handler_i = axis2_msg_ctx_get_current_handler_index(msg_ctx, env);
             /* Invoke the paused handler and rest of the handlers of the paused
              * phase */
-            axis2_phase_invoke_start_from_handler(phase, env, paused_handler_i,
-                                                  msg_ctx);
+            axis2_phase_invoke_start_from_handler(phase, env, paused_handler_i, msg_ctx);
         }
         else
         {
             /* Now we have found the paused phase and invoked the rest of the
              * handlers of that phase, invoke all the phases after that */
-            if (found_match)
+            if(found_match)
             {
                 axis2_phase_invoke(phase, env, msg_ctx);
             }
         }
     }
 
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
-                    "End:axis2_engine_resume_invocation_phases");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "End:axis2_engine_resume_invocation_phases");
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_char_t * AXIS2_CALL
 axis2_engine_get_receiver_fault_code(
     const axis2_engine_t * engine,
     const axutil_env_t * env,
     const axis2_char_t * soap_namespace)
 {
-    if (axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, soap_namespace))
+    if(axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, soap_namespace))
         return AXIOM_SOAP12_FAULT_CODE_RECEIVER;
     return AXIOM_SOAP11_FAULT_CODE_RECEIVER;
 }
@@ -783,85 +722,74 @@
     AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
 
     soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
-    if (!soap_envelope)
+    if(!soap_envelope)
     {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Soap envelope not found in message context");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap envelope not found in message context");
         return AXIS2_FAILURE;
     }
 
     soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
-    if (!soap_header)
+    if(!soap_header)
         return AXIS2_SUCCESS;
 
     header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
-    if (!header_block_ht)
+    if(!header_block_ht)
         return AXIS2_SUCCESS;
 
-    for (hash_index = axutil_hash_first(header_block_ht, env); hash_index;
-         hash_index = axutil_hash_next(env, hash_index))
+    for(hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index
+        = axutil_hash_next(env, hash_index))
     {
         void *hb = NULL;
         axiom_soap_header_block_t *header_block = NULL;
         axis2_char_t *role = NULL;
 
         axutil_hash_this(hash_index, NULL, NULL, &hb);
-        header_block = (axiom_soap_header_block_t *) hb;
+        header_block = (axiom_soap_header_block_t *)hb;
 
-        if (header_block)
+        if(header_block)
         {
-            if (axiom_soap_header_block_is_processed(header_block, env) ||
-                !axiom_soap_header_block_get_must_understand(header_block, env))
+            if(axiom_soap_header_block_is_processed(header_block, env)
+                || !axiom_soap_header_block_get_must_understand(header_block, env))
             {
                 continue;
             }
 
             /* If this header block is not targeted to me then its not my
-               problem. Currently this code only supports the "next" role; we
-               need to fix this to allow the engine/service to be in one or more
-               additional roles and then to check that any headers targeted for
-               that role too have been dealt with. */
+             problem. Currently this code only supports the "next" role; we
+             need to fix this to allow the engine/service to be in one or more
+             additional roles and then to check that any headers targeted for
+             that role too have been dealt with. */
             role = axiom_soap_header_block_get_role(header_block, env);
 
-            if (axis2_msg_ctx_get_is_soap_11(msg_ctx, env) != AXIS2_TRUE)
+            if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env) != AXIS2_TRUE)
             {
                 /* SOAP 1.2 */
-                if (!role ||
-                    axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NEXT) != 0)
+                if(!role || axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NEXT) != 0)
                 {
                     axiom_soap_envelope_t *temp_env =
-                        axiom_soap_envelope_create_default_soap_fault_envelope
-                        (env,
-                         "soapenv:MustUnderstand",
-                         "Header not understood",
-                         AXIOM_SOAP12, NULL, NULL);
-                    axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env,
-                                                          temp_env);
+                        axiom_soap_envelope_create_default_soap_fault_envelope(env,
+                            "soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP12,
NULL,
+                            NULL);
+                    axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env);
                     axis2_msg_ctx_set_wsa_action(msg_ctx, env,
-                                                 "http://www.w3.org/2005/08/addressing/fault");
-                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                        "Must understand soap fault occured");
+                        "http://www.w3.org/2005/08/addressing/fault");
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault
occured");
                     return AXIS2_FAILURE;
                 }
             }
             else
             {
                 /* SOAP 1.1 */
-                if (!role ||
-                    axutil_strcmp(role, AXIOM_SOAP11_SOAP_ACTOR_NEXT) != 0)
+                if(!role || axutil_strcmp(role, AXIOM_SOAP11_SOAP_ACTOR_NEXT) != 0)
                 {
                     axiom_soap_envelope_t *temp_env =
-                        axiom_soap_envelope_create_default_soap_fault_envelope
-                        (env,
-                         "soapenv:MustUnderstand",
-                         "Header not understood",
-                         AXIOM_SOAP11, NULL, NULL);
-                    axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env,
-                                                          temp_env);
+                        axiom_soap_envelope_create_default_soap_fault_envelope(env,
+                            "soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP11,
NULL,
+                            NULL);
+                    axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env);
                     axis2_msg_ctx_set_wsa_action(msg_ctx, env,
-                                                 "http://www.w3.org/2005/08/addressing/fault");
-                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                        "Must understand soap fault occured");
+                        "http://www.w3.org/2005/08/addressing/fault");
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault
occured");
                     return AXIS2_FAILURE;
                 }
 
@@ -884,48 +812,43 @@
     axis2_conf_t *conf = NULL;
     axutil_array_list_t *phases = NULL;
 
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
-                    "Start:axis2_engine_resume_receive");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_receive");
     /* Find and invoke the phases */
     conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
     conf = axis2_conf_ctx_get_conf(conf_ctx, env);
-    phases =
-        axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env);
+    phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env);
 
     axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
     /* Invoking the message receiver */
-    if (axis2_msg_ctx_get_server_side(msg_ctx, env) &&
-        !axis2_msg_ctx_is_paused(msg_ctx, env))
+    if(axis2_msg_ctx_get_server_side(msg_ctx, env) && !axis2_msg_ctx_is_paused(msg_ctx,
env))
     {
         /* Invoke the message receivers */
         axis2_op_ctx_t *op_ctx = NULL;
 
         status = axis2_engine_check_must_understand_headers(env, msg_ctx);
 
-        if (status != AXIS2_SUCCESS)
+        if(status != AXIS2_SUCCESS)
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Checking for must understand headers failed");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Checking for must understand headers
failed");
             return status;
         }
 
         op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-        if (op_ctx)
+        if(op_ctx)
         {
             axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env);
-            if (op)
+            if(op)
             {
                 axis2_msg_recv_t *receiver = NULL;
                 receiver = axis2_op_get_msg_recv(op, env);
-                if (!receiver)
+                if(!receiver)
                 {
                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                         "Message receiver not set in operation description");
                     return AXIS2_FAILURE;
                 }
-                status = axis2_msg_recv_receive(receiver, env, msg_ctx,
-                                                axis2_msg_recv_get_derived
-                                                (receiver, env));
+                status = axis2_msg_recv_receive(receiver, env, msg_ctx, axis2_msg_recv_get_derived(
+                    receiver, env));
             }
         }
     }
@@ -946,10 +869,10 @@
     AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_send");
     /* Invoke the phases */
     op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
-    if (op_ctx)
+    if(op_ctx)
     {
         axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env);
-        if (op)
+        if(op)
         {
             phases = axis2_op_get_out_flow(op, env);
         }
@@ -957,16 +880,16 @@
     axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
 
     /* Invoking transport sender */
-    if (!axis2_msg_ctx_is_paused(msg_ctx, env))
+    if(!axis2_msg_ctx_is_paused(msg_ctx, env))
     {
         /* Write the message to the wire */
         axis2_transport_out_desc_t *transport_out = NULL;
         axis2_transport_sender_t *sender = NULL;
         transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, env);
-        if (transport_out)
+        if(transport_out)
         {
             sender = axis2_transport_out_desc_get_sender(transport_out, env);
-            if (sender)
+            if(sender)
             {
                 status = AXIS2_TRANSPORT_SENDER_INVOKE(sender, env, msg_ctx);
             }

Modified: webservices/axis2/trunk/c/src/core/engine/handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/engine/handler.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/engine/handler.c (original)
+++ webservices/axis2/trunk/c/src/core/engine/handler.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -36,11 +35,10 @@
      * @param msg_ctx pointer to message context
      * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
-     axis2_status_t(
-    AXIS2_CALL * invoke) (
-    axis2_handler_t * handler,
-    const axutil_env_t * env,
-    struct axis2_msg_ctx * msg_ctx);
+    axis2_status_t(AXIS2_CALL * invoke)(
+        axis2_handler_t * handler,
+        const axutil_env_t * env,
+        struct axis2_msg_ctx * msg_ctx);
 };
 
 AXIS2_EXTERN axis2_handler_t *AXIS2_CALL
@@ -50,7 +48,7 @@
     axis2_handler_t *handler = NULL;
 
     handler = AXIS2_MALLOC(env->allocator, sizeof(axis2_handler_t));
-    if (!handler)
+    if(!handler)
     {
         AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
         AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
@@ -76,7 +74,7 @@
     const axis2_handler_t * handler,
     const axutil_env_t * env)
 {
-    if (!(handler->handler_desc))
+    if(!(handler->handler_desc))
         return NULL;
 
     return axis2_handler_desc_get_name(handler->handler_desc, env);
@@ -97,7 +95,7 @@
     const axutil_env_t * env,
     const axis2_char_t * name)
 {
-    if (!(handler->handler_desc))
+    if(!(handler->handler_desc))
         return NULL;
 
     return axis2_handler_desc_get_param(handler->handler_desc, env, name);



Mime
View raw message