/**
* Destroy a response object and associated resources. Note that
* libmicrohttpd may keep some of the resources around if the response
* is still in the queue for some clients, so the memory may not
* necessarily be freed immediatley.
*
* @param response response to destroy
* @ingroup response
*/
void
MHD_destroy_response (struct MHD_Response *response)
{
struct MHD_HTTP_Header *pos;
if (NULL == response)
return;
(void) MHD_mutex_lock_ (&response->mutex);
if (0 != --(response->reference_count))
{
(void) MHD_mutex_unlock_ (&response->mutex);
return;
}
(void) MHD_mutex_unlock_ (&response->mutex);
(void) MHD_mutex_destroy_ (&response->mutex);
if (response->crfc != NULL)
response->crfc (response->crc_cls);
while (NULL != response->first_header)
{
pos = response->first_header;
response->first_header = pos->next;
free (pos->header);
free (pos->value);
free (pos);
}
free (response);
}
static int
gcry_w32_mutex_destroy (void **ppmtx)
{
int res = (MHD_mutex_destroy_ ((MHD_mutex_*)*ppmtx)) ? 0 : EINVAL;
free (*ppmtx);
return res;
}
/**
* Create a response object. The response object can be extended with
* header information and then be used any number of times.
*
* @param size size of the @a data portion of the response
* @param data the data itself
* @param must_free libmicrohttpd should free data when done
* @param must_copy libmicrohttpd must make a copy of @a data
* right away, the data maybe released anytime after
* this call returns
* @return NULL on error (i.e. invalid arguments, out of memory)
* @deprecated use #MHD_create_response_from_buffer instead
* @ingroup response
*/
struct MHD_Response *
MHD_create_response_from_data (size_t size,
void *data, int must_free, int must_copy)
{
struct MHD_Response *response;
void *tmp;
if ((NULL == data) && (size > 0))
return NULL;
if (NULL == (response = malloc (sizeof (struct MHD_Response))))
return NULL;
memset (response, 0, sizeof (struct MHD_Response));
response->fd = -1;
if (MHD_YES != MHD_mutex_create_ (&response->mutex))
{
free (response);
return NULL;
}
if ((must_copy) && (size > 0))
{
if (NULL == (tmp = malloc (size)))
{
(void) MHD_mutex_destroy_ (&response->mutex);
free (response);
return NULL;
}
memcpy (tmp, data, size);
must_free = MHD_YES;
data = tmp;
}
response->crc = NULL;
response->crfc = must_free ? &free : NULL;
response->crc_cls = must_free ? data : NULL;
response->reference_count = 1;
response->total_size = size;
response->data = data;
response->data_size = size;
return response;
}