lighttpd/src/mod_axis2.c - axis-axis2-c-core - Git at Google

 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>

 #include "base.h"
 #include "log.h"
 #include "buffer.h"
 #include "response.h"

 #include "plugin.h"

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

 #include <axutil_error_default.h>
 #include <axutil_log_default.h>
 #include <axutil_thread_pool.h>
 #include <axiom_xml_reader.h>
 #include <axutil_version.h>
 #include <axis2_http_transport.h>
 #include <axis2_conf_ctx.h>
 #include <axis2_conf_init.h>
 #include <axutil_class_loader.h>
 #include <axis2_conf_ctx.h>

 #include <axis2_http_transport.h>
 #include <axis2_msg_ctx.h>
 #include <axis2_http_out_transport_info.h>
 #include <axis2_http_transport_utils.h>
 #include <axis2_http_accept_record.h>
 #include "lighty_stream.h"
 #include "axis2_lighty_out_transport_info.h"

 /* plugin config for all request/connections */
 typedef struct {
 	buffer *axis2c_repo;
     buffer *axis2c_logfile;
     buffer *axis2c_loglevel;
 } plugin_config;

 typedef struct {
 	PLUGIN_DATA;
 	buffer *axis2c_repo_buf;

 	plugin_config **config_storage;

 	plugin_config conf;

     /* mod_axis2 related values */
     axutil_env_t *env;

     axis2_conf_ctx_t *conf_ctx;

 } plugin_data;


 static int axis2_lighty_init_server (server *srv, plugin_data *p_d);

 static int axis2_lighty_process_request (server *srv, connection *con, plugin_data *p);


 /* init the plugin data */
 INIT_FUNC(mod_axis2_init)
 {
 	plugin_data *p;

 	p = calloc(1, sizeof(*p));

 	p->axis2c_repo_buf = buffer_init();
 	return p;
 }

 /* detroy the plugin data */
 FREE_FUNC(mod_axis2_free)
 {
 	plugin_data *p = p_d;

 	UNUSED(srv);

 	if (!p) return HANDLER_GO_ON;

 	if (p->config_storage)
     {
 		size_t i;

 		for (i = 0; i < srv->config_context->used; i++)
         {
 			plugin_config *s = p->config_storage[i];

 			if (!s) continue;

             buffer_free(s->axis2c_repo);

 			free(s);
 		}
 		free(p->config_storage);
 	}

     if (p->conf_ctx && p->env)
     {
         axis2_conf_ctx_free(p->conf_ctx, p->env);
         axutil_env_free(p->env);
         p->conf_ctx = NULL;
         p->env = NULL;
     }

 	buffer_free(p->axis2c_repo_buf);
 	free(p);
 	return HANDLER_GO_ON;
 }

 SETDEFAULTS_FUNC(mod_axis2_set_defaults)
 {
 	plugin_data *p = p_d;
 	size_t i = 0;

     /* values accessing from lighttpd.conf */
 	config_values_t cv[] = {
 		{ "axis2c.repo-path", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },
 		{ "axis2c.logfile", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },
 		{ "axis2c.loglevel", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },
 		{ NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
 	};

 	if (!p) return HANDLER_ERROR;

 	p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));

 	for (i = 0; i < srv->config_context->used; i++)
     {
 		plugin_config *s;

 		s = calloc(1, sizeof(plugin_config));
 		s->axis2c_repo    = buffer_init();
         s->axis2c_logfile = buffer_init ();
         s->axis2c_loglevel = buffer_init ();

 		cv[0].destination = s->axis2c_repo;
         cv[1].destination = s->axis2c_logfile;
         cv[2].destination = s->axis2c_loglevel;

 		p->config_storage[i] = s;

 		if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv))
         {
 			return HANDLER_ERROR;
 		}
 	}

     /* initializing and setting defaults values in axis2/c */
     axis2_lighty_init_server (srv, p);
 	return HANDLER_GO_ON;
 }


 #define PATCH(x)                                \
 	p->conf.x = s->x;
 static int mod_axis2_patch_connection(server *srv, connection *con, plugin_data *p)
 {
 	size_t i, j;
 	plugin_config *s = p->config_storage[0];

 	PATCH(axis2c_repo);

 	/* skip the first, the global context */
 	for (i = 1; i < srv->config_context->used; i++)
     {
 		data_config *dc = (data_config *)srv->config_context->data[i];
 		s = p->config_storage[i];

 		/* condition didn't match */
 		if (!config_check_cond(srv, con, dc)) continue;

 		/* merge config */
 		for (j = 0; j < dc->value->used; j++)
         {
 			data_unset *du = dc->value->data[j];

 			if (buffer_is_equal_string(du->key, CONST_STR_LEN("axis2c.repo-path")))
             {
 				PATCH(axis2c_repo);
 			}
             else if(buffer_is_equal_string(du->key, CONST_STR_LEN("axis2c.logfile")))
             {
                 PATCH(axis2c_logfile);
             }
             else if (buffer_is_equal_string(du->key, CONST_STR_LEN("axis2c.logfile")))
             {
                 PATCH(axis2c_loglevel);
             }
 		}
 	}

 	return 0;
 }
 #undef PATCH


 SUBREQUEST_FUNC(mode_axis2_subrequest_start)
 {
 	plugin_data *p = p_d;
     mod_axis2_patch_connection(srv, con, p);
     axis2_lighty_process_request (srv, con, p);
     return HANDLER_FINISHED;
 }


 static int axis2_lighty_init_server (server *srv, plugin_data *p)
 {
     axutil_env_t *env;
     axis2_conf_t *conf;
     axutil_hash_t* svc_map = NULL;
     axutil_hash_index_t *hi = NULL;
     void* svc = NULL;
     plugin_config *plg;
     axis2_char_t *repo_path = NULL;
     axis2_char_t *log_file = NULL;
     unsigned int log_level = 0;

     if (!p)
     {
         log_error_write(srv, __FILE__, __LINE__, "s",
                         "plugin data is null, unable to proceed");
         return HANDLER_ERROR;
     }

     plg = p->config_storage[0];

     if (!plg)
     {
         log_error_write(srv, __FILE__, __LINE__, "s",
                         "unable to retrieve mod_axis2 plugin from configuration storage");
         return HANDLER_ERROR;
     }

     log_file = (axis2_char_t *)plg->axis2c_logfile->ptr;
     if (!log_file)
     {
         log_error_write(srv, __FILE__, __LINE__, "s",
                         "unable to find axis2c.logfile in lighttpd.conf");
         return HANDLER_ERROR;
     }

     log_level = (unsigned int)plg->axis2c_loglevel->ptr;

     if (!log_level)
     {
         log_error_write(srv, __FILE__, __LINE__, "s",
                         "unable to find axis2c.loglevel in lighttpd.conf");
         return HANDLER_ERROR;
     }


     p->env = axutil_env_create_all (log_file, log_level);

     if (!p->env)
     {
         log_error_write(srv, __FILE__, __LINE__, "sssd",
                         "env creation faild for mod_axis2 log_file",
                         log_file,"and log_level", log_level );
         return HANDLER_ERROR;
     }

     env = p->env;

     /* we are using config_storage to access axis2c.repo value from
      * configuration file */

     repo_path = (axis2_char_t *)plg->axis2c_repo->ptr;

     if (!repo_path)
     {
         log_error_write(srv, __FILE__, __LINE__, "s",
                         "unable to find axis2c.repo-path in lighttpd.conf");
         return HANDLER_ERROR;
     }


     p->conf_ctx = axis2_build_conf_ctx (env, axutil_strdup(env, repo_path));

     if (!p->conf_ctx)
     {
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                         "conf ctx creation failed for %s repo path", repo_path);
     }

     conf = axis2_conf_ctx_get_conf (p->conf_ctx, env);

     if (!conf)
     {
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                         "unable to get conf for %s repo path", repo_path);
     }

     svc_map = axis2_conf_get_all_svcs (conf, env);
     if (!svc_map)
     {
         AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI,
                           "svcs map is NULL");
     }

     for (hi = axutil_hash_first(svc_map, env);
          hi; hi = axutil_hash_next(env, hi))
     {
         void *impl_class = NULL;
         axutil_param_t *impl_info_param = NULL;

         axutil_hash_this(hi, NULL, NULL, &svc);
         if (!svc)
             continue;
         impl_class = axis2_svc_get_impl_class(svc, env);
         if (impl_class)
             continue;
         impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS);
         if (!impl_info_param)
             continue;

         axutil_class_loader_init(env);
         impl_class = axutil_class_loader_create_dll(env, impl_info_param);
         axis2_svc_set_impl_class(svc, env, impl_class);
         if (impl_class)
         {
             AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *) impl_class, env);
         }
     }

     AXIS2_LOG_INFO(env->log, "lighty mod axis2 services loaded");

     return HANDLER_GO_ON;
 }


 #define PTR(x) x->ptr

 static int axis2_lighty_process_request (server *srv, connection *con, plugin_data *p)
 {
     axutil_env_t *env;
     axis2_conf_ctx_t *conf_ctx = NULL;
     unsigned int content_length = 0;
     unsigned int http_version = -1;
     axis2_char_t *request_url = NULL;
     const axis2_char_t *content_type = NULL;
     axis2_http_transport_in_t transport_in;
     axis2_http_transport_out_t transport_out;
     axis2_transport_out_desc_t * out_desc = NULL;
     axis2_transport_in_desc_t * in_desc = NULL;
     axis2_msg_ctx_t *msg_ctx = NULL;
     axutil_stream_t *in_stream = NULL;
     axis2_http_out_transport_info_t *lighty_out_transport_info = NULL;
     buffer *b;

     b = buffer_init ();

     if (!p->env)
     {
         log_error_write(srv, __FILE__, __LINE__, "s",
                         "axis2c env is null, unable to continue");

         return HANDLER_ERROR;
     }

     env = p->env;

     conf_ctx = p->conf_ctx;

     if (!conf_ctx)
     {
         AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "conf ctx is null unable to continue");
         return HANDLER_ERROR;
     }

     /* initialzing transport_in and transport_out structures */
     memset (&transport_in, 0, sizeof(transport_in));
     memset (&transport_out, 0, sizeof(transport_out));

     content_length = (unsigned int)con->request.content_length;
     AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "request content length %d", content_length);

     http_version = con->request.http_version;

     request_url = axutil_strcat (env, PTR(con->uri.scheme), "://", PTR(con->uri.authority),
                                  PTR(con->uri.path), NULL);

     AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "url %s", request_url);

     content_type = con->request.http_content_type;

     AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "http content type %s", content_type);

     out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env),
                                             env, AXIS2_TRANSPORT_ENUM_HTTP);
     /** transport in description */
     in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env),
                                           env, AXIS2_TRANSPORT_ENUM_HTTP);

     /* filling transport_in structure */
     transport_in.request_uri = axutil_strdup (env, request_url);
     transport_in.content_length = content_length;
     transport_in.content_type = (axis2_char_t *)content_type;

     switch (http_version)
     {
         case HTTP_VERSION_1_1:
         {
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "Clinet http version is HTTP 1.1");
         }
         break;
         case HTTP_VERSION_1_0:
         {
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "Client http version is HTTP 1.0");
         }
         break;
     };

     msg_ctx = axis2_msg_ctx_create (env, conf_ctx, in_desc, out_desc);
     transport_in.msg_ctx = msg_ctx;

     lighty_out_transport_info = axis2_lighty_out_transport_info_create (env, srv, con);
     transport_in.out_transport_info = lighty_out_transport_info;

     in_stream = axutil_stream_create_lighty(env, con);
     transport_in.in_stream = in_stream;


     switch (con->request.http_method){
         case HTTP_METHOD_POST:
         {
             transport_in.request_method = AXIS2_HTTP_METHOD_POST;
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing POST request");
         }
         break;
         case HTTP_METHOD_GET:
         {
             transport_in.request_method = AXIS2_HTTP_METHOD_GET;
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing GET request");
         }
         break;
         case HTTP_METHOD_PUT:
         {
             transport_in.request_method = AXIS2_HTTP_METHOD_PUT;
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing PUT request");
         }
         break;
         case HTTP_METHOD_HEAD:
         {
             transport_in.request_method = AXIS2_HTTP_METHOD_HEAD;
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing HEAD request");
         }
         break;
         case HTTP_METHOD_DELETE:
         {
             transport_in.request_method = AXIS2_HTTP_METHOD_DELETE;
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing DELETE request");
         }
         break;
         default:
         {
             AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "http method not handled");
         }
     };

     axis2_http_transport_utils_process_request(env, conf_ctx, &transport_in, &transport_out);

     buffer_copy_off_t (b, transport_out.response_data_length);
     response_header_overwrite(srv, con, CONST_STR_LEN("Content-Length"), CONST_BUF_LEN(b));

     buffer_reset (b);
     buffer_copy_string (b, transport_out.response_data);
 	chunkqueue_append_buffer(con->write_queue, b);

     AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "response %s", b->ptr);
     return HANDLER_GO_ON;
 }

 #undef PTR

 /* this function is called at dlopen() time and inits the callbacks */
 int mod_axis2_plugin_init(plugin *p)
 {
 	p->version     = LIGHTTPD_VERSION_ID;
 	p->name        = buffer_init_string("axis2c");

 	p->init        = mod_axis2_init;
 	p->set_defaults  = mod_axis2_set_defaults;
 	p->cleanup     = mod_axis2_free;
     p->handle_subrequest_start = mode_axis2_subrequest_start;
 	p->data        = NULL;

 	return 0;
 }
	#include <ctype.h>
	#include <stdlib.h>
	#include <string.h>
	#include <stdio.h>

	#include "base.h"
	#include "log.h"
	#include "buffer.h"
	#include "response.h"

	#include "plugin.h"

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include <axutil_error_default.h>
	#include <axutil_log_default.h>
	#include <axutil_thread_pool.h>
	#include <axiom_xml_reader.h>
	#include <axutil_version.h>
	#include <axis2_http_transport.h>
	#include <axis2_conf_ctx.h>
	#include <axis2_conf_init.h>
	#include <axutil_class_loader.h>
	#include <axis2_conf_ctx.h>

	#include <axis2_http_transport.h>
	#include <axis2_msg_ctx.h>
	#include <axis2_http_out_transport_info.h>
	#include <axis2_http_transport_utils.h>
	#include <axis2_http_accept_record.h>
	#include "lighty_stream.h"
	#include "axis2_lighty_out_transport_info.h"

	/* plugin config for all request/connections */
	typedef struct {
	buffer *axis2c_repo;
	buffer *axis2c_logfile;
	buffer *axis2c_loglevel;
	} plugin_config;

	typedef struct {
	PLUGIN_DATA;
	buffer *axis2c_repo_buf;

	plugin_config **config_storage;

	plugin_config conf;

	/* mod_axis2 related values */
	axutil_env_t *env;

	axis2_conf_ctx_t *conf_ctx;

	} plugin_data;


	static int axis2_lighty_init_server (server srv, plugin_data p_d);

	static int axis2_lighty_process_request (server srv, connection con, plugin_data *p);


	/* init the plugin data */
	INIT_FUNC(mod_axis2_init)
	{
	plugin_data *p;

	p = calloc(1, sizeof(*p));

	p->axis2c_repo_buf = buffer_init();
	return p;
	}

	/* detroy the plugin data */
	FREE_FUNC(mod_axis2_free)
	{
	plugin_data *p = p_d;

	UNUSED(srv);

	if (!p) return HANDLER_GO_ON;

	if (p->config_storage)
	{
	size_t i;

	for (i = 0; i < srv->config_context->used; i++)
	{
	plugin_config *s = p->config_storage[i];

	if (!s) continue;

	buffer_free(s->axis2c_repo);

	free(s);
	}
	free(p->config_storage);
	}

	if (p->conf_ctx && p->env)
	{
	axis2_conf_ctx_free(p->conf_ctx, p->env);
	axutil_env_free(p->env);
	p->conf_ctx = NULL;
	p->env = NULL;
	}

	buffer_free(p->axis2c_repo_buf);
	free(p);
	return HANDLER_GO_ON;
	}

	SETDEFAULTS_FUNC(mod_axis2_set_defaults)
	{
	plugin_data *p = p_d;
	size_t i = 0;

	/* values accessing from lighttpd.conf */
	config_values_t cv[] = {
	{ "axis2c.repo-path", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },
	{ "axis2c.logfile", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },
	{ "axis2c.loglevel", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },
	{ NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
	};

	if (!p) return HANDLER_ERROR;

	p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));

	for (i = 0; i < srv->config_context->used; i++)
	{
	plugin_config *s;

	s = calloc(1, sizeof(plugin_config));
	s->axis2c_repo = buffer_init();
	s->axis2c_logfile = buffer_init ();
	s->axis2c_loglevel = buffer_init ();

	cv[0].destination = s->axis2c_repo;
	cv[1].destination = s->axis2c_logfile;
	cv[2].destination = s->axis2c_loglevel;

	p->config_storage[i] = s;

	if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv))
	{
	return HANDLER_ERROR;
	}
	}

	/* initializing and setting defaults values in axis2/c */
	axis2_lighty_init_server (srv, p);
	return HANDLER_GO_ON;
	}


	#define PATCH(x) \
	p->conf.x = s->x;
	static int mod_axis2_patch_connection(server srv, connection con, plugin_data *p)
	{
	size_t i, j;
	plugin_config *s = p->config_storage[0];

	PATCH(axis2c_repo);

	/* skip the first, the global context */
	for (i = 1; i < srv->config_context->used; i++)
	{
	data_config dc = (data_config )srv->config_context->data[i];
	s = p->config_storage[i];

	/* condition didn't match */
	if (!config_check_cond(srv, con, dc)) continue;

	/* merge config */
	for (j = 0; j < dc->value->used; j++)
	{
	data_unset *du = dc->value->data[j];

	if (buffer_is_equal_string(du->key, CONST_STR_LEN("axis2c.repo-path")))
	{
	PATCH(axis2c_repo);
	}
	else if(buffer_is_equal_string(du->key, CONST_STR_LEN("axis2c.logfile")))
	{
	PATCH(axis2c_logfile);
	}
	else if (buffer_is_equal_string(du->key, CONST_STR_LEN("axis2c.logfile")))
	{
	PATCH(axis2c_loglevel);
	}
	}
	}

	return 0;
	}
	#undef PATCH


	SUBREQUEST_FUNC(mode_axis2_subrequest_start)
	{
	plugin_data *p = p_d;
	mod_axis2_patch_connection(srv, con, p);
	axis2_lighty_process_request (srv, con, p);
	return HANDLER_FINISHED;
	}


	static int axis2_lighty_init_server (server srv, plugin_data p)
	{
	axutil_env_t *env;
	axis2_conf_t *conf;
	axutil_hash_t* svc_map = NULL;
	axutil_hash_index_t *hi = NULL;
	void* svc = NULL;
	plugin_config *plg;
	axis2_char_t *repo_path = NULL;
	axis2_char_t *log_file = NULL;
	unsigned int log_level = 0;

	if (!p)
	{
	log_error_write(srv, __FILE__, __LINE__, "s",
	"plugin data is null, unable to proceed");
	return HANDLER_ERROR;
	}

	plg = p->config_storage[0];

	if (!plg)
	{
	log_error_write(srv, __FILE__, __LINE__, "s",
	"unable to retrieve mod_axis2 plugin from configuration storage");
	return HANDLER_ERROR;
	}

	log_file = (axis2_char_t *)plg->axis2c_logfile->ptr;
	if (!log_file)
	{
	log_error_write(srv, __FILE__, __LINE__, "s",
	"unable to find axis2c.logfile in lighttpd.conf");
	return HANDLER_ERROR;
	}

	log_level = (unsigned int)plg->axis2c_loglevel->ptr;

	if (!log_level)
	{
	log_error_write(srv, __FILE__, __LINE__, "s",
	"unable to find axis2c.loglevel in lighttpd.conf");
	return HANDLER_ERROR;
	}


	p->env = axutil_env_create_all (log_file, log_level);

	if (!p->env)
	{
	log_error_write(srv, __FILE__, __LINE__, "sssd",
	"env creation faild for mod_axis2 log_file",
	log_file,"and log_level", log_level );
	return HANDLER_ERROR;
	}

	env = p->env;

	/* we are using config_storage to access axis2c.repo value from
	* configuration file */

	repo_path = (axis2_char_t *)plg->axis2c_repo->ptr;

	if (!repo_path)
	{
	log_error_write(srv, __FILE__, __LINE__, "s",
	"unable to find axis2c.repo-path in lighttpd.conf");
	return HANDLER_ERROR;
	}


	p->conf_ctx = axis2_build_conf_ctx (env, axutil_strdup(env, repo_path));

	if (!p->conf_ctx)
	{
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
	"conf ctx creation failed for %s repo path", repo_path);
	}

	conf = axis2_conf_ctx_get_conf (p->conf_ctx, env);

	if (!conf)
	{
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
	"unable to get conf for %s repo path", repo_path);
	}

	svc_map = axis2_conf_get_all_svcs (conf, env);
	if (!svc_map)
	{
	AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI,
	"svcs map is NULL");
	}

	for (hi = axutil_hash_first(svc_map, env);
	hi; hi = axutil_hash_next(env, hi))
	{
	void *impl_class = NULL;
	axutil_param_t *impl_info_param = NULL;

	axutil_hash_this(hi, NULL, NULL, &svc);
	if (!svc)
	continue;
	impl_class = axis2_svc_get_impl_class(svc, env);
	if (impl_class)
	continue;
	impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS);
	if (!impl_info_param)
	continue;

	axutil_class_loader_init(env);
	impl_class = axutil_class_loader_create_dll(env, impl_info_param);
	axis2_svc_set_impl_class(svc, env, impl_class);
	if (impl_class)
	{
	AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *) impl_class, env);
	}
	}

	AXIS2_LOG_INFO(env->log, "lighty mod axis2 services loaded");

	return HANDLER_GO_ON;
	}


	#define PTR(x) x->ptr

	static int axis2_lighty_process_request (server srv, connection con, plugin_data *p)
	{
	axutil_env_t *env;
	axis2_conf_ctx_t *conf_ctx = NULL;
	unsigned int content_length = 0;
	unsigned int http_version = -1;
	axis2_char_t *request_url = NULL;
	const axis2_char_t *content_type = NULL;
	axis2_http_transport_in_t transport_in;
	axis2_http_transport_out_t transport_out;
	axis2_transport_out_desc_t * out_desc = NULL;
	axis2_transport_in_desc_t * in_desc = NULL;
	axis2_msg_ctx_t *msg_ctx = NULL;
	axutil_stream_t *in_stream = NULL;
	axis2_http_out_transport_info_t *lighty_out_transport_info = NULL;
	buffer *b;

	b = buffer_init ();

	if (!p->env)
	{
	log_error_write(srv, __FILE__, __LINE__, "s",
	"axis2c env is null, unable to continue");

	return HANDLER_ERROR;
	}

	env = p->env;

	conf_ctx = p->conf_ctx;

	if (!conf_ctx)
	{
	AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "conf ctx is null unable to continue");
	return HANDLER_ERROR;
	}

	/* initialzing transport_in and transport_out structures */
	memset (&transport_in, 0, sizeof(transport_in));
	memset (&transport_out, 0, sizeof(transport_out));

	content_length = (unsigned int)con->request.content_length;
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "request content length %d", content_length);

	http_version = con->request.http_version;

	request_url = axutil_strcat (env, PTR(con->uri.scheme), "://", PTR(con->uri.authority),
	PTR(con->uri.path), NULL);

	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "url %s", request_url);

	content_type = con->request.http_content_type;

	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "http content type %s", content_type);

	out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env),
	env, AXIS2_TRANSPORT_ENUM_HTTP);
	/** transport in description */
	in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env),
	env, AXIS2_TRANSPORT_ENUM_HTTP);

	/* filling transport_in structure */
	transport_in.request_uri = axutil_strdup (env, request_url);
	transport_in.content_length = content_length;
	transport_in.content_type = (axis2_char_t *)content_type;

	switch (http_version)
	{
	case HTTP_VERSION_1_1:
	{
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "Clinet http version is HTTP 1.1");
	}
	break;
	case HTTP_VERSION_1_0:
	{
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "Client http version is HTTP 1.0");
	}
	break;
	};

	msg_ctx = axis2_msg_ctx_create (env, conf_ctx, in_desc, out_desc);
	transport_in.msg_ctx = msg_ctx;

	lighty_out_transport_info = axis2_lighty_out_transport_info_create (env, srv, con);
	transport_in.out_transport_info = lighty_out_transport_info;

	in_stream = axutil_stream_create_lighty(env, con);
	transport_in.in_stream = in_stream;


	switch (con->request.http_method){
	case HTTP_METHOD_POST:
	{
	transport_in.request_method = AXIS2_HTTP_METHOD_POST;
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing POST request");
	}
	break;
	case HTTP_METHOD_GET:
	{
	transport_in.request_method = AXIS2_HTTP_METHOD_GET;
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing GET request");
	}
	break;
	case HTTP_METHOD_PUT:
	{
	transport_in.request_method = AXIS2_HTTP_METHOD_PUT;
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing PUT request");
	}
	break;
	case HTTP_METHOD_HEAD:
	{
	transport_in.request_method = AXIS2_HTTP_METHOD_HEAD;
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing HEAD request");
	}
	break;
	case HTTP_METHOD_DELETE:
	{
	transport_in.request_method = AXIS2_HTTP_METHOD_DELETE;
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "processing DELETE request");
	}
	break;
	default:
	{
	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "http method not handled");
	}
	};

	axis2_http_transport_utils_process_request(env, conf_ctx, &transport_in, &transport_out);

	buffer_copy_off_t (b, transport_out.response_data_length);
	response_header_overwrite(srv, con, CONST_STR_LEN("Content-Length"), CONST_BUF_LEN(b));

	buffer_reset (b);
	buffer_copy_string (b, transport_out.response_data);
	chunkqueue_append_buffer(con->write_queue, b);

	AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "response %s", b->ptr);
	return HANDLER_GO_ON;
	}

	#undef PTR

	/* this function is called at dlopen() time and inits the callbacks */
	int mod_axis2_plugin_init(plugin *p)
	{
	p->version = LIGHTTPD_VERSION_ID;
	p->name = buffer_init_string("axis2c");

	p->init = mod_axis2_init;
	p->set_defaults = mod_axis2_set_defaults;
	p->cleanup = mod_axis2_free;
	p->handle_subrequest_start = mode_axis2_subrequest_start;
	p->data = NULL;

	return 0;
	}