You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/09/28 11:53:04 UTC
svn commit: r580276 [15/26] - in /webservices/axis2/trunk/c/src: core/addr/
core/clientapi/ core/context/ core/deployment/ core/description/
core/engine/ core/phaseresolver/ core/receivers/ core/transport/
core/transport/http/common/ core/transport/htt...
Modified: webservices/axis2/trunk/c/src/core/phaseresolver/phase_resolver.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/phaseresolver/phase_resolver.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/phaseresolver/phase_resolver.c (original)
+++ webservices/axis2/trunk/c/src/core/phaseresolver/phase_resolver.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -20,6 +21,7 @@
struct axis2_phase_resolver
{
+
/** axis2 configuration */
axis2_conf_t *axis2_config;
@@ -27,43 +29,40 @@
axis2_svc_t *svc;
};
-static axis2_status_t
-axis2_phase_resolver_build_execution_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
+static axis2_status_t axis2_phase_resolver_build_execution_chains(
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
int type,
- axis2_op_t *op);
-
-static axis2_status_t
-axis2_phase_resolver_build_in_transport_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_transport_in_desc_t *transport);
-
-static axis2_status_t
-axis2_phase_resolver_build_out_transport_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_transport_out_desc_t *transport);
+ axis2_op_t * op);
-static axis2_status_t
-axis2_phase_resolver_engage_to_global_chain(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_module_desc_t *module_desc);
+static axis2_status_t axis2_phase_resolver_build_in_transport_chains(
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_transport_in_desc_t * transport);
+
+static axis2_status_t axis2_phase_resolver_build_out_transport_chains(
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_transport_out_desc_t * transport);
+
+static axis2_status_t axis2_phase_resolver_engage_to_global_chain(
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc);
AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL
axis2_phase_resolver_create(
- const axutil_env_t *env)
+ const axutil_env_t * env)
{
axis2_phase_resolver_t *phase_resolver = NULL;
AXIS2_ENV_CHECK(env, NULL);
phase_resolver = (axis2_phase_resolver_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axis2_phase_resolver_t));
+ sizeof
+ (axis2_phase_resolver_t));
- if (! phase_resolver)
+ if (!phase_resolver)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
@@ -77,8 +76,8 @@
AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL
axis2_phase_resolver_create_with_config(
- const axutil_env_t *env,
- axis2_conf_t *axis2_config)
+ const axutil_env_t * env,
+ axis2_conf_t * axis2_config)
{
axis2_phase_resolver_t *phase_resolver = NULL;
@@ -95,9 +94,9 @@
AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL
axis2_phase_resolver_create_with_config_and_svc(
- const axutil_env_t *env,
- axis2_conf_t *axis2_config,
- axis2_svc_t *svc)
+ const axutil_env_t * env,
+ axis2_conf_t * axis2_config,
+ axis2_svc_t * svc)
{
axis2_phase_resolver_t *phase_resolver = NULL;
@@ -115,15 +114,15 @@
phase_resolver->svc = svc;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name is : %s",
- axis2_svc_get_name(phase_resolver->svc, env));
+ axis2_svc_get_name(phase_resolver->svc, env));
return phase_resolver;
}
AXIS2_EXTERN void AXIS2_CALL
axis2_phase_resolver_free(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -137,8 +136,8 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_build_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env)
{
axutil_hash_index_t *index_i = 0;
axis2_status_t status = AXIS2_FAILURE;
@@ -151,16 +150,16 @@
ops = axis2_svc_get_all_ops(phase_resolver->svc, env);
for (index_i = axutil_hash_first(ops, env); index_i; index_i =
- axutil_hash_next(env, index_i))
+ axutil_hash_next(env, index_i))
{
void *v = NULL;
int j = 0;
axutil_hash_this(index_i, NULL, NULL, &v);
- op = (axis2_op_t *)v;
+ op = (axis2_op_t *) v;
for (j = 1; j < 5; j++)
{
status = axis2_phase_resolver_build_execution_chains(phase_resolver,
- env, j, op);
+ env, j, op);
}
}
@@ -169,41 +168,41 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_build_module_op(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_op_t *op)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_op_t * op)
{
int i = 0;
axis2_status_t status = AXIS2_FAILURE;
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Start:axis2_phase_resolver_build_module_op");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "Start:axis2_phase_resolver_build_module_op");
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "op name is:%s",
- axutil_qname_get_localpart(axis2_op_get_qname(op, env),
- env));
+ axutil_qname_get_localpart(axis2_op_get_qname(op, env),
+ env));
for (i = 1; i < 5; i++)
{
status = axis2_phase_resolver_build_execution_chains(phase_resolver,
- env, i, op);
- if(!status)
+ env, i, op);
+ if (!status)
{
- break;
+ break;
}
}
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "End:axis2_phase_resolver_build_module_op");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "End:axis2_phase_resolver_build_module_op");
return status;
}
static axis2_status_t
axis2_phase_resolver_build_execution_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
int type,
- axis2_op_t *op)
+ axis2_op_t * op)
{
axutil_array_list_t *all_handlers = NULL;
axutil_array_list_t *moduleqnames = NULL;
@@ -212,11 +211,11 @@
int status = AXIS2_FAILURE;
axis2_flow_t *flow = NULL;
axis2_phase_holder_t *phase_holder = NULL;
-
+
/* engage handlers from axis2.xml and from modules */
- moduleqnames = axis2_conf_get_all_engaged_modules(
- phase_resolver->axis2_config, env);
+ moduleqnames =
+ axis2_conf_get_all_engaged_modules(phase_resolver->axis2_config, env);
size = axutil_array_list_size(moduleqnames, env);
@@ -226,33 +225,35 @@
axis2_module_desc_t *module_desc = NULL;
modulename = (axutil_qname_t *) axutil_array_list_get(moduleqnames, env,
- i);
+ i);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "module name is:%s",
- axutil_qname_get_localpart(modulename, env));
- module_desc = axis2_conf_get_module(phase_resolver->axis2_config, env,
- modulename);
+ axutil_qname_get_localpart(modulename, env));
+ module_desc = axis2_conf_get_module(phase_resolver->axis2_config, env,
+ modulename);
if (module_desc)
{
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
flow = axis2_module_desc_get_in_flow(module_desc, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
flow = axis2_module_desc_get_out_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
- flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+ flow =
+ axis2_module_desc_get_fault_in_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
- flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+ flow =
+ axis2_module_desc_get_fault_out_flow(module_desc, env);
break;
}
}
@@ -266,7 +267,7 @@
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_REF,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -280,7 +281,6 @@
return AXIS2_ERROR_GET_STATUS_CODE(env->error);
}
-
for (j = 0; j < count; j++)
{
axis2_handler_desc_t *metadata = NULL;
@@ -290,22 +290,23 @@
metadata = axis2_flow_get_handler(flow, env, j);
phase_rule = axis2_handler_desc_get_rules(metadata, env);
phase_name = axis2_phase_rule_get_name(phase_rule, env);
- if (! phase_name)
+ if (!phase_name)
{
return AXIS2_FAILURE;
}
- if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ && (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
+ (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ && (0 !=
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
if (!all_handlers)
{
all_handlers = axutil_array_list_create(env, 0);
if (!all_handlers)
- {
+ {
return AXIS2_FAILURE;
- }
+ }
}
status = axutil_array_list_add(all_handlers, env, metadata);
if (AXIS2_SUCCESS != status)
@@ -321,16 +322,15 @@
else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "This handler is"
- " trying to added to system pre defined phases , but those"
- " handlers are already added to global chain which run"
- " irrespective of the service");
+ " trying to added to system pre defined phases , but those"
+ " handlers are already added to global chain which run"
+ " irrespective of the service");
}
}
}
}
-
/* process handlers form service.xml */
flow = NULL;
@@ -365,14 +365,16 @@
if (!phase_name || (0 == axutil_strcmp(phase_name, "")))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_IS_NOT_SPECIFED,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
- else if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ else if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ || (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name))
+ || (0 ==
+ axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ || (0 ==
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
if (all_handlers)
{
@@ -380,7 +382,8 @@
all_handlers = NULL;
}
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SERVICE_MODULE_CAN_NOT_REFER_GLOBAL_PHASE, AXIS2_FAILURE);
+ AXIS2_ERROR_SERVICE_MODULE_CAN_NOT_REFER_GLOBAL_PHASE,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -390,9 +393,9 @@
{
all_handlers = axutil_array_list_create(env, 0);
if (!all_handlers)
- {
+ {
return AXIS2_FAILURE;
- }
+ }
}
status = axutil_array_list_add(all_handlers, env, metadata);
@@ -409,7 +412,7 @@
axis2_handler_desc_t *handler_desc = NULL;
handler_desc = axutil_array_list_get(all_handlers,
- env, i);
+ env, i);
axis2_handler_desc_free(handler_desc, env);
}
axutil_array_list_free(all_handlers, env);
@@ -429,7 +432,7 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -438,7 +441,7 @@
axis2_phase_holder_create_with_phases(env, phase_list);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -447,7 +450,7 @@
axis2_phase_holder_create_with_phases(env, phase_list);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -456,7 +459,7 @@
axis2_phase_holder_create_with_phases(env, phase_list);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -482,11 +485,11 @@
if (phase_holder)
{
status = axis2_phase_holder_add_handler(phase_holder,
- env, metadata);
- if(!status)
- {
+ env, metadata);
+ if (!status)
+ {
break;
- }
+ }
}
}
@@ -495,7 +498,7 @@
{
axutil_array_list_free(all_handlers, env);
}
- if(phase_holder)
+ if (phase_holder)
{
axis2_phase_holder_free(phase_holder, env);
}
@@ -505,8 +508,8 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_build_transport_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env)
{
axis2_transport_in_desc_t **transports_in = NULL;
axis2_transport_out_desc_t **transports_out = NULL;
@@ -515,21 +518,21 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- transports_in = axis2_conf_get_all_in_transports(phase_resolver->axis2_config,
- env);
+ transports_in =
+ axis2_conf_get_all_in_transports(phase_resolver->axis2_config, env);
if (!transports_in)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_TRANSPORT_IN_CONFIGURED,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_SUCCESS;
}
- transports_out = axis2_conf_get_all_out_transports(phase_resolver->axis2_config,
- env);
+ transports_out =
+ axis2_conf_get_all_out_transports(phase_resolver->axis2_config, env);
if (!transports_out)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_TRANSPORT_OUT_CONFIGURED,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_SUCCESS;
}
@@ -537,8 +540,11 @@
{
if (transports_in[index_i])
{
- status = axis2_phase_resolver_build_in_transport_chains(phase_resolver,
- env, transports_in[index_i]);
+ status =
+ axis2_phase_resolver_build_in_transport_chains(phase_resolver,
+ env,
+ transports_in
+ [index_i]);
if (AXIS2_SUCCESS != status)
{
return status;
@@ -550,8 +556,11 @@
{
if (transports_out[index_i])
{
- status = axis2_phase_resolver_build_out_transport_chains(phase_resolver,
- env, transports_out[index_i]);
+ status =
+ axis2_phase_resolver_build_out_transport_chains(phase_resolver,
+ env,
+ transports_out
+ [index_i]);
if (AXIS2_SUCCESS != status)
{
return status;
@@ -566,12 +575,11 @@
return AXIS2_SUCCESS;
}
-
static axis2_status_t
axis2_phase_resolver_build_in_transport_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_transport_in_desc_t *transport)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_transport_in_desc_t * transport)
{
int type = 0;
int j = 0;
@@ -588,15 +596,16 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
flow = axis2_transport_in_desc_get_in_flow(transport, env);
phase = axis2_transport_in_desc_get_in_phase(transport, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
- flow = axis2_transport_in_desc_get_fault_in_flow(transport, env);
+ flow =
+ axis2_transport_in_desc_get_fault_in_flow(transport, env);
phase = axis2_transport_in_desc_get_fault_phase(transport, env);
break;
}
@@ -618,7 +627,7 @@
if (rule)
{
status = axis2_phase_rule_set_name(rule, env,
- AXIS2_TRANSPORT_PHASE);
+ AXIS2_TRANSPORT_PHASE);
}
if (AXIS2_SUCCESS != status)
{
@@ -676,12 +685,14 @@
axutil_array_list_free(handlers, env);
}
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
- status = axis2_phase_holder_build_transport_handler_chain(
- phase_holder, env, phase, handlers);
+ status =
+ axis2_phase_holder_build_transport_handler_chain(phase_holder,
+ env, phase,
+ handlers);
if (phase_holder)
{
axis2_phase_holder_free(phase_holder, env);
@@ -701,9 +712,9 @@
static axis2_status_t
axis2_phase_resolver_build_out_transport_chains(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_transport_out_desc_t *transport)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_transport_out_desc_t * transport)
{
int type = 0;
axis2_status_t status = AXIS2_FAILURE;
@@ -718,16 +729,18 @@
switch (type)
{
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
flow = axis2_transport_out_desc_get_out_flow(transport, env);
phase = axis2_transport_out_desc_get_out_phase(transport, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
- flow = axis2_transport_out_desc_get_fault_out_flow(transport, env);
- phase = axis2_transport_out_desc_get_fault_phase(transport, env);
+ flow =
+ axis2_transport_out_desc_get_fault_out_flow(transport, env);
+ phase =
+ axis2_transport_out_desc_get_fault_phase(transport, env);
break;
}
}
@@ -751,12 +764,11 @@
metadata = axis2_flow_get_handler(flow, env, j);
-
rule = axis2_handler_desc_get_rules(metadata, env);
if (rule)
{
status = axis2_phase_rule_set_name(rule, env,
- AXIS2_TRANSPORT_PHASE);
+ AXIS2_TRANSPORT_PHASE);
}
if (AXIS2_SUCCESS != status)
{
@@ -814,16 +826,19 @@
}
axutil_array_list_free(handlers, env);
}
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
- status = axis2_phase_holder_build_transport_handler_chain(
- phase_holder, env, phase, handlers);
+ status =
+ axis2_phase_holder_build_transport_handler_chain(phase_holder,
+ env, phase,
+ handlers);
if (phase_holder)
- {
+ {
axis2_phase_holder_free(phase_holder, env);
- }
+ }
}
else
{
@@ -839,9 +854,9 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_engage_module_globally(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc)
{
axutil_hash_t *svc_grps = NULL;
axutil_hash_index_t *index_i = NULL;
@@ -851,18 +866,18 @@
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
status = axis2_phase_resolver_engage_to_global_chain(phase_resolver, env,
- module_desc);
+ module_desc);
if (AXIS2_SUCCESS != status)
{
return status;
}
- svc_grps = axis2_conf_get_all_svc_grps(phase_resolver->axis2_config, env);
+ svc_grps = axis2_conf_get_all_svc_grps(phase_resolver->axis2_config, env);
if (!svc_grps)
{
return AXIS2_FAILURE;
}
for (index_i = axutil_hash_first(svc_grps, env); index_i; index_i =
- axutil_hash_next(env, index_i))
+ axutil_hash_next(env, index_i))
{
axutil_hash_t *svcs = NULL;
axis2_svc_grp_t *svc_grp = NULL;
@@ -872,10 +887,10 @@
axutil_hash_this(index_i, NULL, NULL, &v);
svc_grp = (axis2_svc_grp_t *) v;
- svcs = axis2_svc_grp_get_all_svcs(svc_grp, env);
+ svcs = axis2_svc_grp_get_all_svcs(svc_grp, env);
for (index_j = axutil_hash_first(svcs, env); index_j; index_j =
- axutil_hash_next(env, index_j))
+ axutil_hash_next(env, index_j))
{
axis2_svc_t *svc = NULL;
void *w = NULL;
@@ -883,16 +898,17 @@
axutil_hash_this(index_j, NULL, NULL, &w);
svc = (axis2_svc_t *) w;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "svc name is:%s",
- axis2_svc_get_name(svc, env));
+ axis2_svc_get_name(svc, env));
status = axis2_svc_add_module_ops(svc, env, module_desc,
- phase_resolver->axis2_config);
+ phase_resolver->axis2_config);
if (AXIS2_SUCCESS != status)
{
return status;
}
- status = axis2_phase_resolver_engage_module_to_svc_from_global(
- phase_resolver, env, svc, module_desc);
+ status =
+ axis2_phase_resolver_engage_module_to_svc_from_global
+ (phase_resolver, env, svc, module_desc);
if (AXIS2_SUCCESS != status)
{
@@ -901,8 +917,7 @@
}
mod_name = axis2_module_desc_get_qname(module_desc, env);
- status = axis2_svc_grp_add_module_qname(svc_grp, env,
- mod_name);
+ status = axis2_svc_grp_add_module_qname(svc_grp, env, mod_name);
if (AXIS2_SUCCESS != status)
{
@@ -914,10 +929,10 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_engage_module_to_svc_from_global(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_svc_t *svc,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_svc_t * svc,
+ axis2_module_desc_t * module_desc)
{
axutil_hash_t *ops = NULL;
axis2_bool_t engaged = AXIS2_FALSE;
@@ -937,7 +952,7 @@
}
for (index_i = axutil_hash_first(ops, env); index_i;
- index_i = axutil_hash_next(env, index_i))
+ index_i = axutil_hash_next(env, index_i))
{
void *v = NULL;
axis2_op_t *op_desc = NULL;
@@ -950,13 +965,14 @@
axutil_hash_this(index_i, NULL, NULL, &v);
op_desc = (axis2_op_t *) v;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation name is : %s",
- axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env));
+ axutil_qname_get_localpart(axis2_op_get_qname
+ (op_desc, env), env));
modules = axis2_op_get_all_modules(op_desc, env);
module_desc_qname = axis2_module_desc_get_qname(module_desc, env);
if (modules)
- {
+ {
size = axutil_array_list_size(modules, env);
- }
+ }
for (j = 0; j < size; j++)
{
axis2_module_desc_t *module_desc_l = NULL;
@@ -965,25 +981,26 @@
module_desc_l = (axis2_module_desc_t *)
axutil_array_list_get(modules, env, j);
- module_desc_qname_l = axis2_module_desc_get_qname(module_desc_l ,
- env);
- if (axutil_qname_equals(module_desc_qname_l, env, module_desc_qname))
+ module_desc_qname_l = axis2_module_desc_get_qname(module_desc_l,
+ env);
+ if (axutil_qname_equals
+ (module_desc_qname_l, env, module_desc_qname))
{
engaged = AXIS2_TRUE;
break;
}
}
-
+
if (AXIS2_TRUE == engaged)
{
continue;
}
-
+
for (type = 1; type < 5; type++)
{
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -992,7 +1009,7 @@
axis2_phase_holder_create_with_phases(env, phase_list);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -1001,7 +1018,7 @@
axis2_phase_holder_create_with_phases(env, phase_list);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -1010,7 +1027,7 @@
axis2_phase_holder_create_with_phases(env, phase_list);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
axutil_array_list_t *phase_list = NULL;
@@ -1025,24 +1042,26 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
flow = axis2_module_desc_get_in_flow(module_desc, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
flow = axis2_module_desc_get_out_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
- flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
+ flow =
+ axis2_module_desc_get_fault_in_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
- flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
+ flow =
+ axis2_module_desc_get_fault_out_flow(module_desc, env);
break;
}
}
@@ -1050,7 +1069,7 @@
{
int handler_count = 0;
- handler_count = axis2_flow_get_handler_count(flow, env);
+ handler_count = axis2_flow_get_handler_count(flow, env);
for (j = 0; j < handler_count; j++)
{
axis2_handler_desc_t *metadata = NULL;
@@ -1067,16 +1086,21 @@
{
return AXIS2_FAILURE;
}
- if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 !=
+ axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) &&
+ (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name))
+ && (0 !=
+ axutil_strcmp(AXIS2_PHASE_POST_DISPATCH,
+ phase_name)) &&
+ (0 !=
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
if (phase_holder)
{
- status = axis2_phase_holder_add_handler(
- phase_holder, env, metadata);
- if(!status)
+ status =
+ axis2_phase_holder_add_handler(phase_holder,
+ env, metadata);
+ if (!status)
{
axis2_phase_holder_free(phase_holder, env);
return status;
@@ -1085,11 +1109,11 @@
}
}
}
-
- if(phase_holder)
- {
+
+ if (phase_holder)
+ {
axis2_phase_holder_free(phase_holder, env);
- }
+ }
}
status = axis2_op_add_to_engaged_module_list(op_desc, env, module_desc);
if (AXIS2_SUCCESS != status)
@@ -1101,12 +1125,11 @@
return AXIS2_SUCCESS;
}
-
static axis2_status_t
axis2_phase_resolver_engage_to_global_chain(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_module_desc_t * module_desc)
{
int type = 0;
axis2_status_t status = AXIS2_FAILURE;
@@ -1120,49 +1143,53 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
axutil_array_list_t *phase_list = NULL;
phase_list =
- axis2_conf_get_in_phases_upto_and_including_post_dispatch(
- phase_resolver->axis2_config, env);
+ axis2_conf_get_in_phases_upto_and_including_post_dispatch
+ (phase_resolver->axis2_config, env);
phase_holder =
axis2_phase_holder_create_with_phases(env, phase_list);
- if (!phase_holder) continue;
+ if (!phase_holder)
+ continue;
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
axutil_array_list_t *phase_list = NULL;
- phase_list = axis2_conf_get_out_flow(phase_resolver->axis2_config,
- env);
+ phase_list =
+ axis2_conf_get_out_flow(phase_resolver->axis2_config, env);
phase_holder =
axis2_phase_holder_create_with_phases(env, phase_list);
- if (!phase_holder) continue;
+ if (!phase_holder)
+ continue;
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
axutil_array_list_t *phase_list = NULL;
- phase_list = axis2_conf_get_in_fault_flow(phase_resolver->
- axis2_config, env);
+ phase_list = axis2_conf_get_in_fault_flow(phase_resolver->
+ axis2_config, env);
phase_holder =
axis2_phase_holder_create_with_phases(env, phase_list);
- if (!phase_holder) continue;
+ if (!phase_holder)
+ continue;
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
axutil_array_list_t *phase_list = NULL;
- phase_list = axis2_conf_get_out_fault_flow(phase_resolver->
- axis2_config, env);
+ phase_list = axis2_conf_get_out_fault_flow(phase_resolver->
+ axis2_config, env);
phase_holder =
axis2_phase_holder_create_with_phases(env, phase_list);
- if (!phase_holder) continue;
+ if (!phase_holder)
+ continue;
break;
}
}
@@ -1171,22 +1198,22 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
flow = axis2_module_desc_get_in_flow(module_desc, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
flow = axis2_module_desc_get_out_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
break;
@@ -1211,13 +1238,14 @@
{
return AXIS2_FAILURE;
}
- if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ || (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
+ (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ || (0 ==
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
- status = axis2_phase_holder_add_handler(phase_holder, env,
- metadata);
+ status = axis2_phase_holder_add_handler(phase_holder, env,
+ metadata);
if (!status)
{
axis2_phase_holder_free(phase_holder, env);
@@ -1227,45 +1255,44 @@
}
}
}
-
- if(phase_holder)
- {
+
+ if (phase_holder)
+ {
axis2_phase_holder_free(phase_holder, env);
- }
+ }
}
return AXIS2_SUCCESS;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_engage_module_to_svc(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_svc_t *svc,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_svc_t * svc,
+ axis2_module_desc_t * module_desc)
{
axutil_hash_t *ops = NULL;
axutil_hash_index_t *index_i = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axutil_qname_t *module_d_qname = NULL;
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Start:axis2_phase_resolver_engage_module_to_svc");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "Start:axis2_phase_resolver_engage_module_to_svc");
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Module %s will be engaged to %s",
- axutil_qname_get_localpart(axis2_module_desc_get_qname(module_desc,
- env), env),
- axis2_svc_get_name(svc, env));
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "Module %s will be engaged to %s",
+ axutil_qname_get_localpart(axis2_module_desc_get_qname
+ (module_desc, env), env),
+ axis2_svc_get_name(svc, env));
ops = axis2_svc_get_all_ops(svc, env);
if (!ops)
{
return AXIS2_FAILURE;
}
status = axis2_svc_add_module_ops(svc, env, module_desc,
- phase_resolver->axis2_config);
+ phase_resolver->axis2_config);
if (AXIS2_SUCCESS != status)
{
@@ -1273,7 +1300,7 @@
}
module_d_qname = axis2_module_desc_get_qname(module_desc, env);
for (index_i = axutil_hash_first(ops, env); index_i; index_i =
- axutil_hash_next(env, index_i))
+ axutil_hash_next(env, index_i))
{
axutil_array_list_t *modules = NULL;
axis2_op_t *op_desc = NULL;
@@ -1297,46 +1324,46 @@
module_desc_l = axutil_array_list_get(modules, env, j);
module_d_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
if (AXIS2_TRUE == axutil_qname_equals(module_d_qname, env,
- module_d_qname_l))
+ module_d_qname_l))
{
engaged = AXIS2_TRUE;
status = AXIS2_SUCCESS;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Module %s already engaged to %s of %s",
- axutil_qname_get_localpart(module_d_qname, env),
- axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env),
- env),
- axis2_svc_get_name(svc, env));
+ "Module %s already engaged to %s of %s",
+ axutil_qname_get_localpart(module_d_qname, env),
+ axutil_qname_get_localpart(axis2_op_get_qname
+ (op_desc, env), env),
+ axis2_svc_get_name(svc, env));
break;
}
}
if (AXIS2_FALSE == engaged)
{
- status = axis2_phase_resolver_engage_module_to_op(
- phase_resolver, env, op_desc, module_desc);
+ status =
+ axis2_phase_resolver_engage_module_to_op(phase_resolver, env,
+ op_desc, module_desc);
if (AXIS2_SUCCESS != status)
{
return status;
}
status = axis2_op_add_to_engaged_module_list(op_desc, env,
- module_desc);
+ module_desc);
}
}
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "End:axis2_phase_resolver_engage_module_to_svc");
- return status;
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+ "End:axis2_phase_resolver_engage_module_to_svc");
+ return status;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_disengage_module_from_svc(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_svc_t *svc,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_svc_t * svc,
+ axis2_module_desc_t * module_desc)
{
axutil_hash_t *ops = NULL;
axutil_hash_index_t *index_i = NULL;
@@ -1350,16 +1377,21 @@
{
return AXIS2_FAILURE;
}
+
/* status = axis2_svc_add_module_ops(svc, env, module_desc, */
+
/* phase_resolver->axis2_config); */
/* if (AXIS2_SUCCESS != status) */
+
/* { */
+
/* return status; */
+
/* } */
module_d_qname = axis2_module_desc_get_qname(module_desc, env);
for (index_i = axutil_hash_first(ops, env); index_i; index_i =
- axutil_hash_next(env, index_i))
+ axutil_hash_next(env, index_i))
{
axutil_array_list_t *modules = NULL;
axis2_op_t *op_desc = NULL;
@@ -1383,40 +1415,42 @@
module_desc_l = axutil_array_list_get(modules, env, j);
module_d_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
if (AXIS2_TRUE == axutil_qname_equals(module_d_qname, env,
- module_d_qname_l))
+ module_d_qname_l))
{
engaged = AXIS2_TRUE;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Module %s already engaged.",
- axutil_qname_get_localpart(module_d_qname, env));
+ "Module %s already engaged.",
+ axutil_qname_get_localpart(module_d_qname,
+ env));
break;
}
}
if (AXIS2_TRUE == engaged)
{
- status = axis2_phase_resolver_disengage_module_from_op(
- phase_resolver, env, op_desc, module_desc);
+ status =
+ axis2_phase_resolver_disengage_module_from_op(phase_resolver,
+ env, op_desc,
+ module_desc);
if (AXIS2_SUCCESS != status)
{
return status;
}
status = axis2_op_remove_from_engaged_module_list(op_desc, env,
- module_desc);
+ module_desc);
}
}
- return status;
+ return status;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_engage_module_to_op(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_op_t *axis_op,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_op_t * axis_op,
+ axis2_module_desc_t * module_desc)
{
int type = 0;
axis2_phase_holder_t *phase_holder = NULL;
@@ -1432,22 +1466,22 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
phases = axis2_op_get_in_flow(axis_op, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
phases = axis2_op_get_out_flow(axis_op, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
phases = axis2_op_get_fault_in_flow(axis_op, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
phases = axis2_op_get_fault_out_flow(axis_op, env);
break;
@@ -1456,29 +1490,27 @@
if (phases)
{
- phase_holder =
- axis2_phase_holder_create_with_phases(env, phases);
+ phase_holder = axis2_phase_holder_create_with_phases(env, phases);
}
-
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
flow = axis2_module_desc_get_in_flow(module_desc, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
flow = axis2_module_desc_get_out_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
break;
@@ -1501,33 +1533,36 @@
metadata = axis2_flow_get_handler(flow, env, j);
phase_rule = axis2_handler_desc_get_rules(metadata, env);
phase_name = axis2_phase_rule_get_name(phase_rule, env);
- if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ && (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
+ (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ && (0 !=
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
status = axis2_phase_holder_add_handler(phase_holder,
- env, metadata);
+ env, metadata);
if (AXIS2_SUCCESS != status)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Handler inclusion failed for %s phase", phase_name);
+ "Handler inclusion failed for %s phase",
+ phase_name);
axis2_phase_holder_free(phase_holder, env);
return status;
}
}
- if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ || (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
+ (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ || (0 ==
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
axutil_array_list_t *phase_list = NULL;
axis2_phase_holder_t *phase_holder = NULL;
phase_list =
- axis2_conf_get_in_phases_upto_and_including_post_dispatch(
- phase_resolver->axis2_config, env);
+ axis2_conf_get_in_phases_upto_and_including_post_dispatch
+ (phase_resolver->axis2_config, env);
if (phase_holder)
{
axis2_phase_holder_free(phase_holder, env);
@@ -1536,7 +1571,9 @@
phase_holder =
axis2_phase_holder_create_with_phases(env, phase_list);
- status = axis2_phase_holder_add_handler(phase_holder, env, metadata);
+ status =
+ axis2_phase_holder_add_handler(phase_holder, env,
+ metadata);
axis2_phase_holder_free(phase_holder, env);
phase_holder = NULL;
if (AXIS2_SUCCESS != status)
@@ -1547,23 +1584,22 @@
}
}
- if(phase_holder)
+ if (phase_holder)
{
axis2_phase_holder_free(phase_holder, env);
phase_holder = NULL;
}
}
-
+
return AXIS2_SUCCESS;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_resolver_disengage_module_from_op(
- axis2_phase_resolver_t *phase_resolver,
- const axutil_env_t *env,
- axis2_op_t *axis_op,
- axis2_module_desc_t *module_desc)
+ axis2_phase_resolver_t * phase_resolver,
+ const axutil_env_t * env,
+ axis2_op_t * axis_op,
+ axis2_module_desc_t * module_desc)
{
int type = 0;
axis2_phase_holder_t *phase_holder = NULL;
@@ -1579,22 +1615,22 @@
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
phases = axis2_op_get_in_flow(axis_op, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
phases = axis2_op_get_out_flow(axis_op, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
phases = axis2_op_get_fault_in_flow(axis_op, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
phases = axis2_op_get_fault_out_flow(axis_op, env);
break;
@@ -1603,29 +1639,27 @@
if (phases)
{
- phase_holder =
- axis2_phase_holder_create_with_phases(env, phases);
+ phase_holder = axis2_phase_holder_create_with_phases(env, phases);
}
-
switch (type)
{
- case AXIS2_IN_FLOW:
+ case AXIS2_IN_FLOW:
{
flow = axis2_module_desc_get_in_flow(module_desc, env);
break;
}
- case AXIS2_OUT_FLOW:
+ case AXIS2_OUT_FLOW:
{
flow = axis2_module_desc_get_out_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_IN_FLOW:
+ case AXIS2_FAULT_IN_FLOW:
{
flow = axis2_module_desc_get_fault_in_flow(module_desc, env);
break;
}
- case AXIS2_FAULT_OUT_FLOW:
+ case AXIS2_FAULT_OUT_FLOW:
{
flow = axis2_module_desc_get_fault_out_flow(module_desc, env);
break;
@@ -1648,33 +1682,36 @@
metadata = axis2_flow_get_handler(flow, env, j);
phase_rule = axis2_handler_desc_get_rules(metadata, env);
phase_name = axis2_phase_rule_get_name(phase_rule, env);
- if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
- (0 != axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 != axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ && (0 != axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) &&
+ (0 != axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ && (0 !=
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
status = axis2_phase_holder_remove_handler(phase_holder,
- env, metadata);
+ env, metadata);
if (AXIS2_SUCCESS != status)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
- "Handler Removal failed for %s phase", phase_name);
+ "Handler Removal failed for %s phase",
+ phase_name);
axis2_phase_holder_free(phase_holder, env);
return status;
}
}
- if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) ||
- (0 == axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+ if ((0 == axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name))
+ || (0 == axutil_strcmp(AXIS2_PHASE_DISPATCH, phase_name)) ||
+ (0 == axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name))
+ || (0 ==
+ axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
{
axutil_array_list_t *phase_list = NULL;
axis2_phase_holder_t *phase_holder = NULL;
phase_list =
- axis2_conf_get_in_phases_upto_and_including_post_dispatch(
- phase_resolver->axis2_config, env);
+ axis2_conf_get_in_phases_upto_and_including_post_dispatch
+ (phase_resolver->axis2_config, env);
if (phase_holder)
{
axis2_phase_holder_free(phase_holder, env);
@@ -1683,7 +1720,9 @@
phase_holder =
axis2_phase_holder_create_with_phases(env, phase_list);
- status = axis2_phase_holder_remove_handler(phase_holder, env, metadata);
+ status =
+ axis2_phase_holder_remove_handler(phase_holder, env,
+ metadata);
axis2_phase_holder_free(phase_holder, env);
phase_holder = NULL;
if (AXIS2_SUCCESS != status)
@@ -1694,13 +1733,12 @@
}
}
- if(phase_holder)
+ if (phase_holder)
{
axis2_phase_holder_free(phase_holder, env);
phase_holder = NULL;
}
}
-
+
return AXIS2_SUCCESS;
}
-
Modified: webservices/axis2/trunk/c/src/core/receivers/msg_recv.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/receivers/msg_recv.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/receivers/msg_recv.c (original)
+++ webservices/axis2/trunk/c/src/core/receivers/msg_recv.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -29,7 +30,8 @@
{
axis2_char_t *scope;
- void* derived;
+ void *derived;
+
/**
* This contain in out synchronous business invoke logic
* @param msg_recv pointer to message receiver
@@ -38,11 +40,12 @@
* @param out_msg_ctx pointer to out message context
* @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
- axis2_status_t (AXIS2_CALL *
- invoke_business_logic)(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- struct axis2_msg_ctx *in_msg_ctx,
- struct axis2_msg_ctx *out_msg_ctx);
+ axis2_status_t(
+ AXIS2_CALL * invoke_business_logic) (
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ struct axis2_msg_ctx * in_msg_ctx,
+ struct axis2_msg_ctx * out_msg_ctx);
/**
* This method is called from axis2_engine_receive method. This method's
@@ -57,28 +60,30 @@
* @param in_msg_ctx pointer to in message context
* @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
- axis2_status_t (AXIS2_CALL *
- receive)(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- struct axis2_msg_ctx *in_msg_ctx,
- void *callback_recv_param);
+ axis2_status_t(
+ AXIS2_CALL * receive) (
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ struct axis2_msg_ctx * in_msg_ctx,
+ void *callback_recv_param);
};
-static axis2_status_t AXIS2_CALL
-axis2_msg_recv_receive_impl(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx,
+static axis2_status_t AXIS2_CALL axis2_msg_recv_receive_impl(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
void *callback_recv_param);
AXIS2_EXPORT axis2_msg_recv_t *AXIS2_CALL
-axis2_msg_recv_create(const axutil_env_t *env)
+axis2_msg_recv_create(
+ const axutil_env_t * env)
{
axis2_msg_recv_t *msg_recv = NULL;
AXIS2_ENV_CHECK(env, NULL);
msg_recv = (axis2_msg_recv_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axis2_msg_recv_t));
+ sizeof(axis2_msg_recv_t));
if (!msg_recv)
{
@@ -86,15 +91,16 @@
return NULL;
}
- msg_recv->scope = axutil_strdup (env, "app*");
+ msg_recv->scope = axutil_strdup(env, "app*");
msg_recv->derived = NULL;
msg_recv->receive = axis2_msg_recv_receive_impl;
return msg_recv;
}
AXIS2_EXPORT void AXIS2_CALL
-axis2_msg_recv_free(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env)
+axis2_msg_recv_free(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -112,9 +118,10 @@
}
AXIS2_EXPORT axis2_svc_skeleton_t *AXIS2_CALL
-axis2_msg_recv_make_new_svc_obj(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- struct axis2_msg_ctx *msg_ctx)
+axis2_msg_recv_make_new_svc_obj(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ struct axis2_msg_ctx * msg_ctx)
{
struct axis2_svc *svc = NULL;
struct axis2_op_ctx *op_ctx = NULL;
@@ -143,12 +150,12 @@
if (!impl_info_param)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return NULL;
}
axutil_allocator_switch_to_global_pool(env->allocator);
-
+
axutil_class_loader_init(env);
impl_class = axutil_class_loader_create_dll(env, impl_info_param);
@@ -156,7 +163,7 @@
if (impl_class)
{
- AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *)impl_class, env);
+ AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *) impl_class, env);
}
axutil_allocator_switch_to_local_pool(env->allocator);
@@ -164,11 +171,11 @@
return impl_class;
}
-
AXIS2_EXPORT axis2_svc_skeleton_t *AXIS2_CALL
-axis2_msg_recv_get_impl_obj(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- struct axis2_msg_ctx *msg_ctx)
+axis2_msg_recv_get_impl_obj(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ struct axis2_msg_ctx * msg_ctx)
{
struct axis2_svc *svc = NULL;
struct axis2_op_ctx *op_ctx = NULL;
@@ -183,14 +190,15 @@
{
return NULL;
}
-
+
return axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx);
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_set_scope(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- const axis2_char_t *scope)
+axis2_msg_recv_set_scope(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ const axis2_char_t * scope)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, scope, AXIS2_FAILURE);
@@ -209,16 +217,18 @@
}
AXIS2_EXPORT axis2_char_t *AXIS2_CALL
-axis2_msg_recv_get_scope(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env)
+axis2_msg_recv_get_scope(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env)
{
return msg_recv->scope;
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_delete_svc_obj(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx)
+axis2_msg_recv_delete_svc_obj(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
{
axis2_svc_t *svc = NULL;
axis2_op_ctx_t *op_ctx = NULL;
@@ -245,7 +255,7 @@
param_value = axutil_param_get_value(scope_param, env);
}
if (param_value && (0 == axutil_strcmp(AXIS2_APPLICATION_SCOPE,
- param_value)))
+ param_value)))
{
return AXIS2_SUCCESS;
}
@@ -254,7 +264,7 @@
if (!impl_info_param)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
dll_desc = axutil_param_get_value(impl_info_param, env);
@@ -262,9 +272,10 @@
}
static axis2_status_t AXIS2_CALL
-axis2_msg_recv_receive_impl(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx,
+axis2_msg_recv_receive_impl(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
void *callback_recv_param)
{
axis2_msg_ctx_t *out_msg_ctx = NULL;
@@ -276,7 +287,7 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
-
+
out_msg_ctx = axis2_core_utils_create_out_msg_ctx(env, msg_ctx);
if (!out_msg_ctx)
{
@@ -289,23 +300,23 @@
axis2_msg_ctx_free(out_msg_ctx, env);
return AXIS2_FAILURE;
}
-
- status = axis2_op_ctx_add_msg_ctx(op_ctx, env, out_msg_ctx);
+
+ status = axis2_op_ctx_add_msg_ctx(op_ctx, env, out_msg_ctx);
if (!status)
{
axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx);
axis2_msg_ctx_free(out_msg_ctx, env);
return status;
}
- status = axis2_op_ctx_add_msg_ctx(op_ctx, env, msg_ctx);
+ status = axis2_op_ctx_add_msg_ctx(op_ctx, env, msg_ctx);
- if(!status)
+ if (!status)
{
return status;
}
status = axis2_msg_recv_invoke_business_logic(msg_recv, env,
- msg_ctx, out_msg_ctx);
+ msg_ctx, out_msg_ctx);
if (AXIS2_SUCCESS != status)
{
axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx);
@@ -320,14 +331,15 @@
axis2_msg_ctx_free(out_msg_ctx, env);
return AXIS2_FAILURE;
}
- if ( axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env))
+ if (axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env))
{
- axiom_soap_envelope_t *soap_envelope = axis2_msg_ctx_get_soap_envelope(
- out_msg_ctx, env);
+ axiom_soap_envelope_t *soap_envelope =
+ axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env);
if (soap_envelope)
{
- axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope,
- env);
+ axiom_soap_body_t *body =
+ axiom_soap_envelope_get_body(soap_envelope,
+ env);
if (body)
{
/* in case of a SOAP fault, we got to return failure so that
@@ -336,7 +348,7 @@
{
status = AXIS2_FAILURE;
axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env,
- soap_envelope);
+ soap_envelope);
axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, NULL);
}
else
@@ -348,8 +360,8 @@
}
}
}
- axis2_engine_free(engine, env);
- if (!axis2_msg_ctx_is_paused(out_msg_ctx, env) &&
+ axis2_engine_free(engine, env);
+ if (!axis2_msg_ctx_is_paused(out_msg_ctx, env) &&
!axis2_msg_ctx_is_keep_alive(out_msg_ctx, env))
{
axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx);
@@ -358,27 +370,30 @@
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_set_invoke_business_logic(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
+axis2_msg_recv_set_invoke_business_logic(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
void *func)
{
msg_recv->invoke_business_logic = func;
return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_invoke_business_logic(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- struct axis2_msg_ctx *in_msg_ctx,
- struct axis2_msg_ctx *out_msg_ctx)
-{
- return msg_recv->invoke_business_logic (msg_recv, env, in_msg_ctx,
- out_msg_ctx);
-}
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+axis2_msg_recv_invoke_business_logic(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ struct axis2_msg_ctx * in_msg_ctx,
+ struct axis2_msg_ctx * out_msg_ctx)
+{
+ return msg_recv->invoke_business_logic(msg_recv, env, in_msg_ctx,
+ out_msg_ctx);
+}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_set_derived(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
+axis2_msg_recv_set_derived(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
void *derived)
{
msg_recv->derived = derived;
@@ -386,15 +401,17 @@
}
AXIS2_EXPORT void *AXIS2_CALL
-axis2_msg_recv_get_derived(const axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env)
+axis2_msg_recv_get_derived(
+ const axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env)
{
- return msg_recv->derived;
+ return msg_recv->derived;
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_set_receive(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
+axis2_msg_recv_set_receive(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
void *func)
{
msg_recv->receive = func;
@@ -402,12 +419,11 @@
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_msg_recv_receive(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx,
+axis2_msg_recv_receive(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
void *callback_recv_param)
{
- return msg_recv->receive(msg_recv, env, msg_ctx,
- callback_recv_param);
+ return msg_recv->receive(msg_recv, env, msg_ctx, callback_recv_param);
}
-
Modified: webservices/axis2/trunk/c/src/core/receivers/raw_xml_in_out_msg_recv.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/receivers/raw_xml_in_out_msg_recv.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/receivers/raw_xml_in_out_msg_recv.c (original)
+++ webservices/axis2/trunk/c/src/core/receivers/raw_xml_in_out_msg_recv.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -26,13 +27,14 @@
static axis2_status_t AXIS2_CALL
axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(
- axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx,
- axis2_msg_ctx_t *new_msg_ctx);
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_msg_ctx_t * new_msg_ctx);
AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL
-axis2_raw_xml_in_out_msg_recv_create(const axutil_env_t *env)
+axis2_raw_xml_in_out_msg_recv_create(
+ const axutil_env_t * env)
{
axis2_msg_recv_t *msg_recv = NULL;
axis2_status_t status = AXIS2_FAILURE;
@@ -51,16 +53,17 @@
return NULL;
}
- axis2_msg_recv_set_invoke_business_logic(msg_recv, env,
- axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync);
+ axis2_msg_recv_set_invoke_business_logic(msg_recv, env,
+ axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync);
return msg_recv;
}
static axis2_status_t AXIS2_CALL
-axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(axis2_msg_recv_t *msg_recv,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx,
- axis2_msg_ctx_t *new_msg_ctx)
+axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(
+ axis2_msg_recv_t * msg_recv,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_msg_ctx_t * new_msg_ctx)
{
axis2_svc_skeleton_t *svc_obj = NULL;
axis2_op_ctx_t *op_ctx = NULL;
@@ -95,7 +98,7 @@
if (!svc_obj)
{
const axis2_char_t *svc_name = NULL;
- axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env);
+ axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if (svc)
{
@@ -107,10 +110,10 @@
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "Impl object for service '%s' not set in message receiver. %d :: %s",
- svc_name,
- env->error->error_number,
- AXIS2_ERROR_GET_MESSAGE(env->error));
+ "Impl object for service '%s' not set in message receiver. %d :: %s",
+ svc_name,
+ env->error->error_number,
+ AXIS2_ERROR_GET_MESSAGE(env->error));
status = AXIS2_FAILURE;
}
else
@@ -129,7 +132,7 @@
om_node = axiom_soap_body_get_base_node(body, env);
om_element = axiom_node_get_data_element(om_node, env);
om_node = axiom_node_get_first_element(om_node, env);
- }
+ }
else if (0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_soap_envelope_t *envelope = NULL;
@@ -161,8 +164,9 @@
{
axis2_char_t *function_name = NULL;
- function_name = (axis2_char_t *) axutil_array_list_get(
- function_arr, env, i);
+ function_name =
+ (axis2_char_t *) axutil_array_list_get(function_arr,
+ env, i);
if (0 == axutil_strcmp(function_name, local_name))
{
matches = AXIS2_TRUE;
@@ -178,35 +182,39 @@
else
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE);
+ AXIS2_ERROR_OM_ELEMENT_MISMATCH,
+ AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_OM_ELEMENT_INVALID_STATE,
+ AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
- {
+ {
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE);
+ AXIS2_ERROR_RPC_NEED_MATCHING_CHILD,
+ AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE);
+ AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
if (status == AXIS2_SUCCESS)
{
skel_invoked = AXIS2_TRUE;
- result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx);
+ result_node =
+ AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx);
}
if (result_node)
@@ -224,8 +232,9 @@
}
else
{
- body_content_element = axiom_element_create(env, NULL, res_name,
- ns, &body_content_node);
+ body_content_element =
+ axiom_element_create(env, NULL, res_name, ns,
+ &body_content_node);
axiom_node_add_child(body_content_node, env, result_node);
}
}
@@ -241,13 +250,13 @@
}
}
- if (msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
+ if (msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
- if ( axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env))
+ if (axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env))
{
/* service implementation has set the envelope,
useful when setting a SOAP fault.
@@ -255,7 +264,7 @@
return AXIS2_SUCCESS;
}
- /* create the soap envelope here*/
+ /* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, "soapenv");
if (!env_ns)
{
@@ -289,7 +298,7 @@
if (status != AXIS2_SUCCESS)
{
- /* something went wrong. set a SOAP Fault*/
+ /* something went wrong. set a SOAP Fault */
const axis2_char_t *fault_value_str = "env:Sender";
const axis2_char_t *fault_reason_str = NULL;
const axis2_char_t *err_msg = NULL;
@@ -310,23 +319,28 @@
}
soap_fault = axiom_soap_fault_create_default_fault(env, out_body,
- fault_value_str, fault_reason_str, soap_version);
+ fault_value_str,
+ fault_reason_str,
+ soap_version);
if (fault_node)
{
- fault_detail = axiom_soap_fault_detail_create_with_parent (env, soap_fault);
- axiom_soap_fault_detail_add_detail_entry (fault_detail, env, fault_node);
+ fault_detail =
+ axiom_soap_fault_detail_create_with_parent(env, soap_fault);
+ axiom_soap_fault_detail_add_detail_entry(fault_detail, env,
+ fault_node);
}
}
if (body_content_node)
{
- axiom_node_add_child(out_node , env, body_content_node);
- status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
+ axiom_node_add_child(out_node, env, body_content_node);
+ status =
+ axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
}
else if (soap_fault)
{
- axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
- status = AXIS2_SUCCESS;
+ axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
+ status = AXIS2_SUCCESS;
}
else
{
@@ -335,12 +349,13 @@
default_envelope = NULL;
}
-
return status;
}
-AXIS2_EXPORT int axis2_get_instance(struct axis2_msg_recv **inst,
- const axutil_env_t *env)
+AXIS2_EXPORT int
+axis2_get_instance(
+ struct axis2_msg_recv **inst,
+ const axutil_env_t * env)
{
*inst = axis2_raw_xml_in_out_msg_recv_create(env);
if (!(*inst))
@@ -351,8 +366,10 @@
return AXIS2_SUCCESS;
}
-AXIS2_EXPORT int axis2_remove_instance(struct axis2_msg_recv *inst,
- const axutil_env_t *env)
+AXIS2_EXPORT int
+axis2_remove_instance(
+ struct axis2_msg_recv *inst,
+ const axutil_env_t * env)
{
if (inst)
{
@@ -360,5 +377,3 @@
}
return AXIS2_SUCCESS;
}
-
-
Modified: webservices/axis2/trunk/c/src/core/receivers/svr_callback.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/receivers/svr_callback.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/receivers/svr_callback.c (original)
+++ webservices/axis2/trunk/c/src/core/receivers/svr_callback.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -24,7 +25,8 @@
};
AXIS2_EXPORT axis2_svr_callback_t *AXIS2_CALL
-axis2_svr_callback_create(const axutil_env_t *env)
+axis2_svr_callback_create(
+ const axutil_env_t * env)
{
axis2_svr_callback_t *svr_callback = NULL;
@@ -43,8 +45,9 @@
}
AXIS2_EXPORT void AXIS2_CALL
-axis2_svr_callback_free(axis2_svr_callback_t *svr_callback,
- const axutil_env_t *env)
+axis2_svr_callback_free(
+ axis2_svr_callback_t * svr_callback,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -57,9 +60,10 @@
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_svr_callback_handle_result(axis2_svr_callback_t *svr_callback,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx)
+axis2_svr_callback_handle_result(
+ axis2_svr_callback_t * svr_callback,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
{
axis2_engine_t *engine = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
@@ -81,9 +85,10 @@
}
AXIS2_EXPORT axis2_status_t AXIS2_CALL
-axis2_svr_callback_handle_fault(axis2_svr_callback_t *svr_callback,
- const axutil_env_t *env,
- axis2_msg_ctx_t *msg_ctx)
+axis2_svr_callback_handle_fault(
+ axis2_svr_callback_t * svr_callback,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
{
axis2_engine_t *engine = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
@@ -103,8 +108,7 @@
return AXIS2_FAILURE;
}
- fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx, NULL, NULL);
+ fault_ctx =
+ axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx, NULL, NULL);
return axis2_engine_send_fault(engine, env, fault_ctx);
}
-
-
Modified: webservices/axis2/trunk/c/src/core/transport/http/common/http_header.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/transport/http/common/http_header.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/transport/http/common/http_header.c (original)
+++ webservices/axis2/trunk/c/src/core/transport/http/common/http_header.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -29,34 +30,33 @@
AXIS2_EXTERN axis2_http_header_t *AXIS2_CALL
axis2_http_header_create(
- const axutil_env_t *env,
- const axis2_char_t *name,
- const axis2_char_t *value)
+ const axutil_env_t * env,
+ const axis2_char_t * name,
+ const axis2_char_t * value)
{
axis2_http_header_t *http_header = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_ENV_CHECK(env, NULL);
AXIS2_ENV_CHECK(env, NULL);
- http_header = (axis2_http_header_t *)AXIS2_MALLOC
- (env->allocator, sizeof(
- axis2_http_header_t));
+ http_header = (axis2_http_header_t *) AXIS2_MALLOC
+ (env->allocator, sizeof(axis2_http_header_t));
- if (! http_header)
+ if (!http_header)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- http_header->name = (axis2_char_t *)axutil_strdup(env, name);
- http_header->value = (axis2_char_t *)axutil_strdup(env, value);
+ http_header->name = (axis2_char_t *) axutil_strdup(env, name);
+ http_header->value = (axis2_char_t *) axutil_strdup(env, value);
return http_header;
}
AXIS2_EXTERN axis2_http_header_t *AXIS2_CALL
axis2_http_header_create_by_str(
- const axutil_env_t *env,
- const axis2_char_t *str)
+ const axutil_env_t * env,
+ const axis2_char_t * str)
{
axis2_char_t *tmp_str = NULL;
axis2_char_t *ch = NULL;
@@ -66,21 +66,20 @@
AXIS2_ENV_CHECK(env, NULL);
tmp_str = axutil_strdup(env, str);
- if (! tmp_str)
+ if (!tmp_str)
{
return NULL;
}
/* remove trailing \r\n */
- if ('\r' == tmp_str[axutil_strlen(tmp_str)-2])
+ if ('\r' == tmp_str[axutil_strlen(tmp_str) - 2])
{
- tmp_str[axutil_strlen(tmp_str)-2] = '\0';
+ tmp_str[axutil_strlen(tmp_str) - 2] = '\0';
}
- ch = strchr((const char *)tmp_str, ':');
- if (! ch)
+ ch = strchr((const char *) tmp_str, ':');
+ if (!ch)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HEADER,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HEADER, AXIS2_FAILURE);
AXIS2_FREE(env->allocator, tmp_str);
return NULL;
}
@@ -98,8 +97,8 @@
AXIS2_EXTERN void AXIS2_CALL
axis2_http_header_free(
- axis2_http_header_t *http_header,
- const axutil_env_t *env)
+ axis2_http_header_t * http_header,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -116,39 +115,34 @@
return;
}
-
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axis2_http_header_to_external_form(
- axis2_http_header_t *http_header,
- const axutil_env_t *env)
+ axis2_http_header_t * http_header,
+ const axutil_env_t * env)
{
axis2_ssize_t len = 0;
axis2_char_t *external_form = NULL;
AXIS2_ENV_CHECK(env, NULL);
len = axutil_strlen(http_header->name) +
- axutil_strlen(http_header->value) + 8;
- external_form = (axis2_char_t *) AXIS2_MALLOC(env->allocator,
- len);
+ axutil_strlen(http_header->value) + 8;
+ external_form = (axis2_char_t *) AXIS2_MALLOC(env->allocator, len);
sprintf(external_form, "%s: %s%s", http_header->name,
http_header->value, AXIS2_HTTP_CRLF);
return external_form;
}
-
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axis2_http_header_get_name(
- const axis2_http_header_t *http_header,
- const axutil_env_t *env)
+ const axis2_http_header_t * http_header,
+ const axutil_env_t * env)
{
return http_header->name;
}
-
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-
axis2_http_header_get_value(
- const axis2_http_header_t *http_header,
- const axutil_env_t *env)
+ const axis2_http_header_t * http_header,
+ const axutil_env_t * env)
{
return http_header->value;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org