void AXIS2_CALL axis2_tcp_server_free( axis2_transport_receiver_t * server, const axutil_env_t * env) { axis2_tcp_server_impl_t *server_impl = NULL; AXIS2_ENV_CHECK(env, void); server_impl = AXIS2_INTF_TO_IMPL(server); if (server_impl->svr_thread) { axis2_tcp_svr_thread_destroy(server_impl->svr_thread, env); axis2_tcp_svr_thread_free(server_impl->svr_thread, env); server_impl->svr_thread = NULL; } if (server_impl->conf_ctx_private) { axis2_conf_ctx_free(server_impl->conf_ctx_private, env); server_impl->conf_ctx_private = NULL; } /** * Do not free this. It may own to some other object */ server_impl->conf_ctx = NULL; AXIS2_FREE(env->allocator, server_impl); return; }
AXIS2_EXTERN void AXIS2_CALL axis2_amqp_receiver_free( axis2_transport_receiver_t* receiver, const axutil_env_t* env) { AXIS2_ENV_CHECK_VOID(env); axis2_amqp_receiver_resource_pack_t* receiver_resource_pack = NULL; receiver_resource_pack = AXIS2_AMQP_RECEIVER_TO_RESOURCE_PACK(receiver); if(receiver_resource_pack->qpid_receiver) { axis2_qpid_receiver_free(receiver_resource_pack->qpid_receiver, env); receiver_resource_pack->qpid_receiver = NULL; } if(receiver_resource_pack->conf_ctx_private) { axis2_conf_ctx_free(receiver_resource_pack->conf_ctx_private, env); receiver_resource_pack->conf_ctx_private = NULL; } receiver_resource_pack->conf_ctx = NULL; /* Do not free this. It may be owned by some other object */ AXIS2_FREE(env->allocator, receiver_resource_pack); }
void AXIS2_CALL axis2_xmpp_server_free( axis2_transport_receiver_t *server, const axutil_env_t *env) { axis2_xmpp_server_impl_t *impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); impl = AXIS2_INTF_TO_IMPL(server); if (impl->svr_thread) { AXIS2_XMPP_SVR_THREAD_DESTROY(impl->svr_thread, env); AXIS2_XMPP_SVR_THREAD_FREE(impl->svr_thread, env); impl->svr_thread = NULL; } if (impl->conf_ctx_private) { axis2_conf_ctx_free(impl->conf_ctx_private, env); impl->conf_ctx_private = NULL; } /** * Do not free this. It may belong to some other object */ impl->conf_ctx = NULL; AXIS2_FREE(env->allocator, impl); }
void axis2_test_conf_ctx_init(axutil_env_t *env ) { struct axis2_conf *conf = NULL; struct axis2_svc_grp_ctx *svc_grp_ctx1 = NULL; struct axis2_svc_grp_ctx *svc_grp_ctx2 = NULL; struct axis2_svc_grp *svc_grp1 = NULL; struct axis2_svc_grp *svc_grp2 = NULL; struct axis2_conf_ctx *conf_ctx = NULL; struct axis2_svc_ctx *svc_ctx1 = NULL; struct axis2_svc_ctx *svc_ctx2 = NULL; struct axis2_svc *svc1 = NULL; struct axis2_svc *svc2 = NULL; struct axutil_qname *qname1 = NULL; struct axutil_qname *qname2 = NULL; struct axis2_op_ctx *op_ctx1 = NULL; struct axis2_op_ctx *op_ctx2 = NULL; struct axis2_op *op = NULL; struct axutil_hash_t *op_ctx_map = NULL; struct axutil_hash_t *svc_ctx_map = NULL; struct axutil_hash_t *svc_grp_ctx_map = NULL; axis2_status_t status = AXIS2_FAILURE; conf = axis2_conf_create(env); CUT_ASSERT_PTR_NOT_EQUAL(conf, NULL, 1); conf_ctx = axis2_conf_ctx_create(env, conf); CUT_ASSERT_PTR_NOT_EQUAL(conf_ctx, NULL, 1); svc_grp1 = axis2_svc_grp_create(env); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp1, NULL, 0); svc_grp2 = axis2_svc_grp_create(env); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp2, NULL, 0); svc_grp_ctx1 = axis2_svc_grp_ctx_create(env, svc_grp1, conf_ctx); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp_ctx1, NULL, 0); svc_grp_ctx2 = axis2_svc_grp_ctx_create(env, svc_grp2, conf_ctx); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp_ctx2, NULL, 0); qname1 = axutil_qname_create(env, "name1", NULL, NULL); CUT_ASSERT_PTR_NOT_EQUAL(qname1, NULL, 0); qname2 = axutil_qname_create(env, "name2", NULL, NULL); CUT_ASSERT_PTR_NOT_EQUAL(qname2, NULL, 0); svc1 = axis2_svc_create_with_qname(env, qname1); CUT_ASSERT_PTR_NOT_EQUAL(svc1, NULL, 0); svc2 = axis2_svc_create_with_qname(env, qname2); CUT_ASSERT_PTR_NOT_EQUAL(svc2, NULL, 0); svc_ctx1 = axis2_svc_ctx_create(env, svc1, svc_grp_ctx1); CUT_ASSERT_PTR_NOT_EQUAL(svc_ctx1, NULL, 0); svc_ctx2 = axis2_svc_ctx_create(env, svc2, svc_grp_ctx2); CUT_ASSERT_PTR_NOT_EQUAL(svc_ctx1, NULL, 0); op = axis2_op_create(env); CUT_ASSERT_PTR_NOT_EQUAL(op, NULL, 0); op_ctx1 = axis2_op_ctx_create(env, op, svc_ctx1); CUT_ASSERT_PTR_NOT_EQUAL(op_ctx1, NULL, 0); op_ctx2 = axis2_op_ctx_create(env, op, svc_ctx2); CUT_ASSERT_PTR_NOT_EQUAL(op_ctx2, NULL, 0); op_ctx_map = axis2_conf_ctx_get_op_ctx_map(conf_ctx, env); CUT_ASSERT_PTR_NOT_EQUAL(op_ctx_map, NULL, 0); if (op_ctx_map) { axutil_hash_set(op_ctx_map, "op_ctx1", AXIS2_HASH_KEY_STRING, op_ctx1); axutil_hash_set(op_ctx_map, "op_ctx2", AXIS2_HASH_KEY_STRING, op_ctx2); } svc_ctx_map = axis2_conf_ctx_get_svc_ctx_map(conf_ctx, env); CUT_ASSERT_PTR_NOT_EQUAL(svc_ctx_map, NULL, 0); if (svc_ctx_map) { axutil_hash_set(svc_ctx_map, "svc_ctx1", AXIS2_HASH_KEY_STRING, svc_ctx1); axutil_hash_set(svc_ctx_map, "svc_ctx2", AXIS2_HASH_KEY_STRING, svc_ctx2); } svc_grp_ctx_map = axis2_conf_ctx_get_svc_grp_ctx_map(conf_ctx, env); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp_ctx_map, NULL, 0); if (svc_grp_ctx_map) { axutil_hash_set(svc_ctx_map, "svc_grp_ctx1", AXIS2_HASH_KEY_STRING, svc_grp_ctx1); axutil_hash_set(svc_ctx_map, "svc_grp_ctx2", AXIS2_HASH_KEY_STRING, svc_grp_ctx2); } status = axis2_conf_ctx_init(conf_ctx, env, conf); CUT_ASSERT_INT_EQUAL(status, AXIS2_SUCCESS, 0); printf("Error code : %d\n", env->error->error_number); /* CUT_ASSERT_INT_EQUAL(env->error->status_code, AXIS2_SUCCESS, 0); */ /* To avoid warning of not using cut_str_equal */ CUT_ASSERT_STR_EQUAL("", "", 0); axis2_conf_ctx_free(conf_ctx, env); }
AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL axis2_conf_ctx_create( const axutil_env_t * env, axis2_conf_t * conf) { axis2_conf_ctx_t *conf_ctx = NULL; conf_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_conf_ctx_t)); if(!conf_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); return NULL; } conf_ctx->base = NULL; conf_ctx->conf = NULL; conf_ctx->root_dir = NULL; conf_ctx->op_ctx_map = NULL; conf_ctx->svc_ctx_map = NULL; conf_ctx->svc_grp_ctx_map = NULL; conf_ctx->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); if(!conf_ctx->mutex) { axis2_conf_ctx_free(conf_ctx, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create thread mutex"); return NULL; } if(conf) conf_ctx->conf = conf; conf_ctx->base = axis2_ctx_create(env); if(!(conf_ctx->base)) { axis2_conf_ctx_free(conf_ctx, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create base context"); return NULL; } conf_ctx->op_ctx_map = axutil_hash_make(env); if(!(conf_ctx->op_ctx_map)) { axis2_conf_ctx_free(conf_ctx, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create operation context map"); return NULL; } conf_ctx->svc_ctx_map = axutil_hash_make(env); if(!(conf_ctx->svc_ctx_map)) { axis2_conf_ctx_free(conf_ctx, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service context map"); return NULL; } conf_ctx->svc_grp_ctx_map = axutil_hash_make(env); if(!(conf_ctx->svc_grp_ctx_map)) { axis2_conf_ctx_free(conf_ctx, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service group context map"); return NULL; } return conf_ctx; }
AXIS2_EXTERN void AXIS2_CALL axis2_svc_client_free( axis2_svc_client_t * svc_client, const axutil_env_t * env) { if(!svc_client) { return; } if(svc_client->headers) { axis2_svc_client_remove_all_headers(svc_client, env); axutil_array_list_free(svc_client->headers, env); svc_client->headers = NULL; } if(svc_client->svc && !svc_client->keep_externally_passed_ctx_and_svc) { axis2_svc_free(svc_client->svc, env); } if(svc_client->callback_recv) { AXIS2_CALLBACK_RECV_FREE(svc_client->callback_recv, env); } if(svc_client->op_client) { axis2_op_client_free(svc_client->op_client, env); svc_client->op_client = NULL; } if(svc_client->options) { axis2_options_free(svc_client->options, env); } if(svc_client->listener_manager) { axis2_listener_manager_free(svc_client->listener_manager, env); } if(svc_client->conf_ctx && !svc_client->keep_externally_passed_ctx_and_svc) { axis2_conf_ctx_free(svc_client->conf_ctx, env); } if(svc_client->auth_type) { AXIS2_FREE(env->allocator, svc_client->auth_type); } if(svc_client->http_headers) { axis2_svc_client_set_http_info(svc_client, env, NULL); } AXIS2_FREE(env->allocator, svc_client); return; }