static ret_t
get_info (cherokee_plugin_loader_t  *loader,
	  const char                *module,
	  int                        flags,
	  cherokee_plugin_info_t   **info,
	  void                     **dl_handler)
{
	ret_t             ret;
	cherokee_buffer_t info_name = CHEROKEE_BUF_INIT;

	/* Build the info struct string
	 */
	cherokee_buffer_add_va (&info_name, "cherokee_%s_info", module);

	/* Open it
	 */
	ret = dylib_open (loader, module, flags, dl_handler);
	if (ret != ret_ok) {
		cherokee_buffer_mrproper (&info_name);
		return ret_error;
	}

	*info = get_sym_from_dlopen_handler (*dl_handler, info_name.buf);
	if (*info == NULL) {
		cherokee_buffer_mrproper (&info_name);
		return ret_not_found;
	}

	/* Free the info struct string
	 */
	cherokee_buffer_mrproper (&info_name);
	return ret_ok;
}

ret_t
cherokee_url_mrproper (cherokee_url_t *url)
{
	cherokee_buffer_mrproper (&url->host);
	cherokee_buffer_mrproper (&url->request);
	return ret_ok;
}

static ret_t
parse_if (cherokee_buffer_t *buf, const char *if_entry, size_t len_entry, cherokee_boolean_t show)
{
    char              *begin;
    char              *end;
    cherokee_buffer_t  token = CHEROKEE_BUF_INIT;

    cherokee_buffer_add_str (&token, "%if ");
    cherokee_buffer_add (&token, if_entry, len_entry);
    cherokee_buffer_add_str (&token, "%");

    begin = strstr (buf->buf, token.buf);
    if (begin == NULL)
        goto error;

    end = strstr (begin, "%fi%");
    if (end == NULL)
        goto error;

    if (show) {
        cherokee_buffer_remove_chunk (buf, end - buf->buf, 4);
        cherokee_buffer_remove_chunk (buf, begin - buf->buf, token.len);
    } else {
        cherokee_buffer_remove_chunk (buf, begin - buf->buf, (end+4) - begin);
    }

    cherokee_buffer_mrproper (&token);
    return ret_ok;
error:
    cherokee_buffer_mrproper (&token);
    return ret_error;
}

ret_t
cherokee_validator_parse_basic (cherokee_validator_t *validator, char *str, cuint_t str_len)
{
	char              *colon;
	cherokee_buffer_t  auth = CHEROKEE_BUF_INIT;

	/* Decode base64
	 */
	cherokee_buffer_add (&auth, str, str_len);
	cherokee_buffer_decode_base64 (&auth);

	/* Look for the user:passwd structure
	 */
	colon = strchr (auth.buf, ':');
	if (colon == NULL)
		goto error;

	/* Copy user and password
	 */
	cherokee_buffer_add (&validator->user, auth.buf, colon - auth.buf);
	cherokee_buffer_add (&validator->passwd, colon+1, auth.len  - ((colon+1) - auth.buf));

	TRACE (ENTRIES, "Parse basic auth got user=%s, passwd=%s\n", validator->user.buf, validator->passwd.buf);

	/* Clean up and exit
	 */
	cherokee_buffer_mrproper (&auth);
	return ret_ok;

error:
	cherokee_buffer_mrproper (&auth);
	return ret_error;
}

ret_t
cherokee_handler_ssi_free (cherokee_handler_ssi_t *hdl)
{
	cherokee_buffer_mrproper (&hdl->dir);
	cherokee_buffer_mrproper (&hdl->source);
	cherokee_buffer_mrproper (&hdl->render);
	return ret_ok;
}

ret_t
cherokee_plugin_loader_mrproper (cherokee_plugin_loader_t *loader)
{
	cherokee_buffer_mrproper (&loader->module_dir);
	cherokee_buffer_mrproper (&loader->deps_dir);

	cherokee_avl_mrproper (&loader->table, free_entry);
	return ret_ok;
}

ret_t
cherokee_validator_digest_response (cherokee_validator_t  *validator,
				    char                  *A1,
				    cherokee_buffer_t     *buf,
				    cherokee_connection_t *conn)
{
	ret_t              ret;
	cherokee_buffer_t a2 = CHEROKEE_BUF_INIT;

	/* A1 has to be in string of length 32:
	 * MD5_digest(user":"realm":"passwd)
	 */

	/* Sanity checks
	 */
	if (A1 == NULL)
		return ret_deny;

	if (cherokee_buffer_is_empty (&validator->nonce))
		return ret_deny;

	/* Build A2
	 */
	ret = digest_HA2 (validator, &a2, conn);
	if (ret != ret_ok)
		goto error;

	/* Build the final string
	 */
	cherokee_buffer_ensure_size (buf, 32 + a2.len + validator->nonce.len + 4);

	cherokee_buffer_add (buf, A1, 32);
	cherokee_buffer_add_str (buf, ":");
	cherokee_buffer_add_buffer (buf, &validator->nonce);
	cherokee_buffer_add_str (buf, ":");

	if (!cherokee_buffer_is_empty (&validator->qop)) {
		if (!cherokee_buffer_is_empty (&validator->nc))
			cherokee_buffer_add_buffer (buf, &validator->nc);
		cherokee_buffer_add_str (buf, ":");
		if (!cherokee_buffer_is_empty (&validator->cnonce))
			cherokee_buffer_add_buffer (buf, &validator->cnonce);
		cherokee_buffer_add_str (buf, ":");
		cherokee_buffer_add_buffer (buf, &validator->qop);
		cherokee_buffer_add_str (buf, ":");
	}

	cherokee_buffer_add_buffer (buf, &a2);
	cherokee_buffer_encode_md5_digest (buf);
	cherokee_buffer_mrproper (&a2);

	return ret_ok;

error:
	cherokee_buffer_mrproper (&a2);
	return ret;
}

ret_t
cherokee_logger_ncsa_free (cherokee_logger_ncsa_t *logger)
{
	cherokee_buffer_mrproper (&logger->now_dtm);
	cherokee_buffer_mrproper (&logger->referer);
	cherokee_buffer_mrproper (&logger->useragent);

	return ret_ok;
}

ret_t
cherokee_request_header_mrproper (cherokee_request_header_t *request)
{
	cherokee_buffer_mrproper (&request->user);
	cherokee_buffer_mrproper (&request->password);
	cherokee_buffer_mrproper (&request->extra_headers);

	cherokee_url_mrproper (&request->url);
	return ret_ok;
}

ret_t
cherokee_handler_proxy_conn_free (cherokee_handler_proxy_conn_t *pconn)
{
	cherokee_socket_close    (&pconn->socket);
	cherokee_socket_mrproper (&pconn->socket);

	cherokee_buffer_mrproper (&pconn->post.buf_temp);
	cherokee_buffer_mrproper (&pconn->header_in_raw);

	return ret_ok;
}

ret_t
cherokee_post_mrproper (cherokee_post_t *post)
{
	cherokee_buffer_mrproper (&post->send.buffer);
	cherokee_buffer_mrproper (&post->chunked.buffer);
	cherokee_buffer_mrproper (&post->read_header_100cont);
	cherokee_buffer_mrproper (&post->header_surplus);
	cherokee_buffer_mrproper (&post->progress_id);

	return ret_ok;
}

static ret_t
props_free  (cherokee_handler_tmi_props_t *props)
{
    zmq_close (props->socket);
    zmq_term (props->context);
    cherokee_buffer_mrproper (&props->reply);
    cherokee_buffer_mrproper (&props->subscriberid);
    cherokee_buffer_mrproper (&props->version);
    cherokee_buffer_mrproper (&props->dossiername);
    cherokee_buffer_mrproper (&props->endpoint);
    return ret_ok;
}

static ret_t
props_free  (cherokee_handler_dbslayer_props_t *props)
{
	if (props->balancer)
		cherokee_balancer_free (props->balancer);

	cherokee_buffer_mrproper (&props->user);
	cherokee_buffer_mrproper (&props->password);
	cherokee_buffer_mrproper (&props->db);

	return ret_ok;
}

ret_t
cherokee_source_mrproper (cherokee_source_t *src)
{
	if (src->free) {
		src->free (src);
	}

	cherokee_buffer_mrproper (&src->original);
	cherokee_buffer_mrproper (&src->unix_socket);
	cherokee_buffer_mrproper (&src->host);

	return ret_ok;
}

ret_t
cherokee_header_op_free (cherokee_header_op_t *op)
{
	if (unlikely (op == NULL)) {
		return ret_ok;
	}

	cherokee_buffer_mrproper (&op->header);
	cherokee_buffer_mrproper (&op->value);

	free (op);
	return ret_ok;
}

static void
entry_free (void *entry)
{
	cherokee_resolv_cache_entry_t *e = entry;

	if (e->addr) {
		freeaddrinfo (e->addr);
	}

	cherokee_buffer_mrproper (&e->ip_str);
	cherokee_buffer_mrproper (&e->ip_str_all);
	free(entry);
}

ret_t
cherokee_handler_dirlist_props_free  (cherokee_handler_dirlist_props_t *props)
{
    cherokee_list_content_free (&props->notice_files, (cherokee_list_free_func)file_match_free);
    cherokee_list_content_free (&props->hidden_files, (cherokee_list_free_func)file_match_free);

    cherokee_buffer_mrproper (&props->header);
    cherokee_buffer_mrproper (&props->footer);
    cherokee_buffer_mrproper (&props->entry);
    cherokee_buffer_mrproper (&props->css);
    cherokee_buffer_mrproper (&props->icon_web_dir);

    return cherokee_handler_props_free_base (HANDLER_PROPS(props));
}

ret_t
cherokee_validator_file_props_free_base (cherokee_validator_file_props_t *props)
{
	cherokee_buffer_mrproper (&props->password_file);

	return cherokee_validator_props_free_base (VALIDATOR_PROPS(props));
}

static ret_t
find_empty_port (int starting, int *port)
{
	ret_t             ret;
	cherokee_socket_t s;
	int               p     = starting;
	cherokee_buffer_t bind_ = CHEROKEE_BUF_INIT;

	cherokee_buffer_add_str (&bind_, "127.0.0.1");

	cherokee_socket_init (&s);
	cherokee_socket_set_client (&s, AF_INET);

	while (true) {
		ret = cherokee_socket_bind (&s, p, &bind_);
		if (ret == ret_ok)
			break;

		p += 1;
		if (p > 0XFFFF)
			return ret_error;
	}

	cherokee_socket_close (&s);

	cherokee_socket_mrproper (&s);
	cherokee_buffer_mrproper (&bind_);

	*port = p;
	return ret_ok;
}

static ret_t
do_download__read_body (cherokee_downloader_t *downloader, void *param)
{
    ret_t             ret;
    ssize_t           len;
    cherokee_buffer_t tmp = CHEROKEE_BUF_INIT;

    UNUSED(param);

    /* Write down
     */
    len = write (output_fd, downloader->body.buf, downloader->body.len);
    if (len > 0) {
        ret = cherokee_buffer_move_to_begin (&downloader->body, len);
        if (ret != ret_ok) return ret;
    }

    /* Print info
     */
    cherokee_buffer_add_fsize (&tmp, downloader->content_length);
    cherokee_buffer_add_str   (&tmp, " of ");
    cherokee_buffer_add_fsize (&tmp, downloader->info.body_recv);

    if (! quiet) {
        fprintf (stderr, "\rDownloading: %s", tmp.buf);
        fflush(stderr);
    }

    cherokee_buffer_mrproper (&tmp);
    return ret_ok;
}