int mk_conn_write(int socket)
{
int ret = -1;
struct client_session *cs;
struct sched_list_node *sched;
struct sched_connection *conx;
MK_TRACE("[FD %i] Connection Handler / write", socket);
/* Plugin hook */
ret = mk_plugin_event_write(socket);
switch(ret) {
case MK_PLUGIN_RET_EVENT_OWNED:
return MK_PLUGIN_RET_CONTINUE;
case MK_PLUGIN_RET_EVENT_CLOSE:
return -1;
case MK_PLUGIN_RET_EVENT_CONTINUE:
break; /* just return controller to invoker */
}
MK_TRACE("[FD %i] Normal connection write handling", socket);
sched = mk_sched_get_thread_conf();
conx = mk_sched_get_connection(sched, socket);
if (!conx) {
MK_TRACE("[FD %i] Registering new connection");
if (mk_sched_register_client(socket, sched) == -1) {
MK_TRACE("[FD %i] Close requested", socket);
return -1;
}
mk_epoll_change_mode(sched->epoll_fd, socket,
MK_EPOLL_READ, MK_EPOLL_LEVEL_TRIGGERED);
return 0;
}
mk_sched_update_conn_status(sched, socket, MK_SCHEDULER_CONN_PROCESS);
/* Get node from schedule list node which contains
* the information regarding to the current client/socket
*/
cs = mk_session_get(socket);
if (!cs) {
/* This is a ghost connection that doesn't exist anymore.
* Closing it could accidentally close some other thread's
* socket, so pass it to remove_client that checks it's ours.
*/
mk_sched_remove_client(sched, socket);
return 0;
}
ret = mk_handler_write(socket, cs);
/* if ret < 0, means that some error
* happened in the writer call, in the
* other hand, 0 means a successful request
* processed, if ret > 0 means that some data
* still need to be send.
*/
if (ret < 0) {
mk_request_free_list(cs);
mk_session_remove(socket);
return -1;
}
else if (ret == 0) {
return mk_http_request_end(socket);
}
else if (ret > 0) {
return 0;
}
/* avoid to make gcc cry :_( */
return -1;
}
static inline void thread_cb_init_vars()
{
int close;
int type = libco_param.type;
struct mk_vhost_handler *handler = libco_param.handler;
struct mk_http_session *session = libco_param.session;
struct mk_http_request *request = libco_param.request;
struct mk_thread *th = libco_param.th;
struct mk_http_thread *mth;
//struct mk_plugin *plugin;
/*
* Until this point the th->callee already set the variables, so we
* wait until the core wanted to resume so we really trigger the
* output callback.
*/
co_switch(th->caller);
if (type == MK_HTTP_THREAD_LIB) {
/* Invoke the handler callback */
handler->cb(request, handler->data);
/*
* Once the callback finished, we need to sanitize the connection
* so other further requests can be processed.
*/
int ret;
struct mk_sched_worker *sched;
struct mk_channel *channel;
channel = request->session->channel;
sched = mk_sched_get_thread_conf();
MK_EVENT_NEW(channel->event);
ret = mk_event_add(sched->loop,
channel->fd,
MK_EVENT_CONNECTION,
MK_EVENT_READ, channel->event);
if (ret == -1) {
//return -1;
}
/* Save temporal session */
mth = request->thread;
/*
* Finalize request internally, if ret == -1 means we should
* ask to shutdown the connection.
*/
ret = mk_http_request_end(session, session->server);
if (ret == -1) {
close = MK_TRUE;
}
else {
close = MK_FALSE;
}
mk_http_thread_purge(mth, close);
/* Return control to caller */
mk_thread_yield(th);
}
else if (type == MK_HTTP_THREAD_PLUGIN) {
/* FIXME: call plugin handler callback with params */
}
}
