static inline void mk_http_status_completed(struct client_session *cs)
{
mk_bug(cs->status == MK_REQUEST_STATUS_COMPLETED);
cs->status = MK_REQUEST_STATUS_COMPLETED;
mk_list_del(&cs->request_incomplete);
}
/*
* @METHOD_NAME: chan_free
* @METHOD_DESC: release a given channel.
* @METHOD_PROTO: void chan_free(mk_thread_channel_t *chan)
* @METHOD_PARAM: chan the target channel to be released.
* @METHOD_RETURN: this method do not return any value.
*/
void mk_thread_channel_free(struct mk_thread_channel *chan)
{
assert(chan);
if (chan->receiver != -1) {
mk_list_del(&chan->_head);
}
mk_mem_free(chan);
}
int cgi_req_del(struct cgi_request *r)
{
if (!r) return 1;
mk_list_del(&r->_head);
mk_api->mem_free(r);
return 0;
}
void mk_server_listen_free()
{
struct mk_list *tmp;
struct mk_list *head;
struct mk_server_listen *listener;
mk_list_foreach_safe(head, tmp, server_listen) {
listener = mk_list_entry(head, struct mk_server_listen, _head);
mk_list_del(&listener->_head);
mk_mem_free(listener);
}
void mk_server_listen_free()
{
struct mk_list *list;
struct mk_list *tmp;
struct mk_list *head;
struct mk_server_listen *listener;
list = MK_TLS_GET(mk_tls_server_listen);
mk_list_foreach_safe(head, tmp, list) {
listener = mk_list_entry(head, struct mk_server_listen, _head);
mk_list_del(&listener->_head);
mk_mem_free(listener);
}
int mk_http_thread_destroy(struct mk_http_thread *mth)
{
struct mk_thread *th;
/* Unlink from scheduler thread list */
mk_list_del(&mth->_head);
/* release original memory context */
th = mth->parent;
mth->session->channel->event->type = MK_EVENT_CONNECTION;
mk_thread_destroy(th);
return 0;
}
/*
* Move a http thread context from sched->thread to sched->threads_purge list.
* On this way the scheduler will release or reasign the resource later.
*/
int mk_http_thread_purge(struct mk_http_thread *mth, int close)
{
struct mk_sched_worker *sched;
sched = mk_sched_get_thread_conf();
if (!sched) {
return -1;
}
mth->close = close;
mk_list_del(&mth->_head);
mk_list_add(&mth->_head, &sched->threads_purge);
return 0;
}
struct cache_req_t *cache_req_new() {
struct mk_list *pool = pthread_getspecific(cache_req_pool);
struct cache_req_t *req;
if (mk_list_is_empty(pool) == -1) {
// printf("reusing an exhisting request!\n");
req = mk_list_entry_first(pool, struct cache_req_t, _head);
mk_list_del(&req->_head);
if (req->buf->filled) {
pipe_buf_flush(req->buf);
}
}
int duda_service_destroy(struct duda_service *ds)
{
/* Free paths */
mk_mem_free(ds->path_root);
mk_mem_free(ds->path_log);
mk_mem_free(ds->path_data);
mk_mem_free(ds->path_html);
mk_mem_free(ds->path_service);
/* Close handle */
dlclose(ds->dl_handle);
mk_list_del(&ds->_head);
mk_mem_free(ds);
return 0;
}
int tcp_conn_del(struct tcp_conn *conn)
{
struct flb_in_tcp_config *ctx;
ctx = conn->ctx;
flb_pack_state_reset(&conn->pack_state);
/* Unregister the file descriptior from the event-loop */
mk_event_del(ctx->evl, &conn->event);
/* Release resources */
mk_list_del(&conn->_head);
close(conn->fd);
flb_free(conn->buf_data);
flb_free(conn);
return 0;
}
/*
* Copy inherit bytes from old chunk to new chunk and set as current
* chunk.
*/
int fcgi_fd_set_chunk(struct fcgi_fd *fd, struct chunk *a, size_t inherit)
{
struct chunk *b = fd->chunk;
size_t b_pos, a_pos;
struct chunk_ptr tmp;
chunk_retain(a);
if (b && inherit > 0) {
check(b->write >= inherit,
"Not enough used on old chunk to inherit.");
check(a->size - a->write > inherit,
"Not enough free space on new chunk to inherit.");
a_pos = a->write;
b_pos = b->write - inherit;
memcpy(a->data + a_pos, b->data + b_pos, inherit);
a_pos += inherit;
tmp.parent = a;
tmp.len = a->size - a_pos;
tmp.data = a->data + a_pos;
check(!chunk_set_write_ptr(a, tmp),
"Failed to set new write pointer.");
chunk_release(b);
} else if (b) {
chunk_release(b);
} else {
check(inherit == 0, "There are no chunks to inherit from.");
}
fd->chunk = a;
return 0;
error:
if (mk_list_is_empty(&a->_head)) {
mk_list_del(&a->_head);
}
return -1;
}
static void mk_thread_channel_elem_free(struct mk_thread_channel_elem *elem)
{
assert(elem);
mk_list_del(&elem->_head);
mk_mem_free(elem);
}
