trunk/freehttpd/response.c

#include "response.h"
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

freehttpd_response_t *
freehttpd_response_init (FILE *stream, const char *version, size_t version_len,
                         freehttpd_status_t status)
{
    freehttpd_response_t *response = calloc (1, sizeof (freehttpd_response_t));

    if (response == NULL)
        return NULL;

    response->stream = stream;
    response->version = version == NULL ? NULL : strdup (version);
    response->version_length = version == NULL    ? 0
                               : version_len == 0 ? strlen (version)
                                                  : version_len;
    response->status.code = status;
    response->status.text
        = status != 0 ? freehttpd_response_status_text (status) : NULL;
    response->status.status_text_length = 0;
    response->headers = NULL;
    response->headers_length = 0;
    response->buffer = NULL;
    response->buffer_length = 0;

    return response;
}

const char *
freehttpd_response_status_text (freehttpd_status_t status)
{
    switch (status)
        {
        case FREEHTTPD_STATUS_OK:
            return "OK";
        case FREEHTTPD_STATUS_BAD_REQUEST:
            return "Bad Request";
        case FREEHTTPD_STATUS_NOT_FOUND:
            return "Not Found";
        case FREEHTTPD_STATUS_METHOD_NOT_ALLOWED:
            return "Method Not Allowed";
        case FREEHTTPD_STATUS_INTERNAL_SERVER_ERROR:
            return "Internal Server Error";
        case FREEHTTPD_STATUS_NOT_IMPLEMENTED:
            return "Not Implemented";
        case FREEHTTPD_STATUS_FORBIDDEN:
            return "Forbidden";
        default:
            return "Unknown Status";
        }
}

const char *
freehttpd_response_status_description (freehttpd_status_t status)
{
    switch (status)
        {
        case FREEHTTPD_STATUS_BAD_REQUEST:
            return "Your browser sent a request that this server could not "
                   "understand.";
        case FREEHTTPD_STATUS_NOT_FOUND:
            return "The requested URL was not found on this server.";
        case FREEHTTPD_STATUS_METHOD_NOT_ALLOWED:
            return "The requested method is not allowed for the URL.";
        case FREEHTTPD_STATUS_NOT_IMPLEMENTED:
            return "The server does not support the action requested by the "
                   "browser.";
        case FREEHTTPD_STATUS_FORBIDDEN:
            return "You don't have permission to access the requested URL on "
                   "this server.";
        default:
            return "The server encountered an internal error or "
                   "misconfiguration and was unable to complete your request.";
        }
}

void
freehttpd_response_set_status (freehttpd_response_t *response,
                               freehttpd_status_t status)
{
    response->status.code = status;
    response->status.text = freehttpd_response_status_text (status);
}

void
freehttpd_response_add_default_headers (freehttpd_response_t *response)
{
    response->headers
        = realloc (response->headers, sizeof (freehttpd_header_t)
                                          * (response->headers_length + 3));
    response->headers[response->headers_length++]
        = freehttpd_header_init_stack ("Server", "freehttpd", 6, 9);
    response->headers[response->headers_length++]
        = freehttpd_header_init_stack ("Connection", "close", 10, 5);

    struct tm *time_info;
    time_t raw_time;
    time (&raw_time);
    time_info = gmtime (&raw_time);

    char time_str[64];
    size_t time_strlen = strftime (time_str, sizeof (time_str),
                                   "%a, %d %b %Y %H:%M:%S GMT", time_info);

    response->headers[response->headers_length++]
        = freehttpd_header_init_stack ("Date", time_str, 4, time_strlen);
}

freehttpd_header_t *
freehttpd_response_add_header (freehttpd_response_t *response, const char *name,
                               size_t name_len, const char *value_fmt, ...)
{
    va_list args;
    char *final_value = NULL;
    freehttpd_header_t *header;

    va_start (args, value_fmt);
    (void) (vasprintf (&final_value, value_fmt, args) + 1);
    va_end (args);

    response->headers
        = realloc (response->headers, sizeof (freehttpd_header_t)
                                          * (response->headers_length + 1));
    response->headers[response->headers_length++]
        = freehttpd_header_init_stack (name, NULL, name_len, 0);

    header = &response->headers[response->headers_length - 1];
    header->value = final_value;
    header->value_length = strlen (final_value);

    return response->headers + (response->headers_length - 1);
}

ecode_t
freehttpd_response_head_send (const freehttpd_response_t *response)
{
    int ret = 0;

    ret = fprintf (response->stream, "HTTP/%s %d %s\r\n", response->version,
                   response->status.code, response->status.text);

    if (ret < 0)
        return E_SYSCALL_WRITE;

    for (size_t i = 0; i < response->headers_length; i++)
        {
            ret = fprintf (response->stream, "%s: %s\r\n",
                           response->headers[i].name,
                           response->headers[i].value);

            if (ret < 0)
                return E_SYSCALL_WRITE;
        }

    fflush (response->stream);
    return E_OK;
}

ecode_t
freehttpd_response_begin_body (freehttpd_response_t *response)
{
    if (fwrite ("\r\n", 1, 2, response->stream) != 2)
        return E_SYSCALL_WRITE;

    fflush (response->stream);
    return E_OK;
}

ecode_t
freehttpd_response_begin_end (freehttpd_response_t *response)
{
    return freehttpd_response_begin_body (response);
}

size_t
freehttpd_response_write (freehttpd_response_t *response, const void *data,
                          size_t size, size_t n)
{
    size_t wsize = fwrite (data, size, n, response->stream);

    if (wsize > 0)
        {
            int old_errno = errno;
            fflush (response->stream);
            errno = old_errno;
        }

    return wsize;
}

ecode_t
freehttpd_response_printf (freehttpd_response_t *response, const char *format,
                           ...)
{
    va_list args;
    va_start (args, format);
    int ret = vfprintf (response->stream, format, args);
    va_end (args);

    if (ret < 0)
        return E_SYSCALL_WRITE;

    return E_OK;
}

ecode_t
freehttpd_response_bprintf (freehttpd_response_t *response, const char *format,
                            ...)
{
    va_list args;
    va_start (args, format);
    char *str = NULL;
    int ret = vasprintf (&str, format, args);
    va_end (args);

    if (ret < 0)
        return E_SYSCALL_WRITE;

    size_t new_len = strlen (str) + 1;
    response->buffer_length += new_len;
    response->buffer = realloc (response->buffer, response->buffer_length);
    memcpy (response->buffer + response->buffer_length - new_len, str, new_len);
    free (str);

    return E_OK;
}

ecode_t
freehttpd_response_flush (freehttpd_response_t *response)
{
    if (response->buffer == NULL)
        return E_OK;

    size_t written = 0;

    while (written < response->buffer_length)
        {
            ssize_t ret
                = fwrite (response->buffer + written, 1,
                          response->buffer_length - written, response->stream);

            if (ret < 0)
                return E_SYSCALL_WRITE;

            written += ret;
        }

    fflush (response->stream);
    free (response->buffer);
    response->buffer = NULL;
    response->buffer_length = 0;

    return E_OK;
}

void
freehttpd_response_free (freehttpd_response_t *response)
{
    if (response == NULL)
        return;

    if (response->version != NULL)
        free (response->version);

    if (response->headers != NULL)
        {
            for (size_t i = 0; i < response->headers_length; i++)
                {
                    free (response->headers[i].name);
                    free (response->headers[i].value);
                }
        }

    free (response->buffer);
    free (response);
}
1	#include "response.h"
2	#include <errno.h>
3	#include <stdarg.h>
4	#include <stdio.h>
5	#include <stdlib.h>
6	#include <string.h>
7	#include <sys/socket.h>
8	#include <time.h>
9	#include <unistd.h>
10
11	freehttpd_response_t *
12	freehttpd_response_init (FILE stream, const char version, size_t version_len,
13	freehttpd_status_t status)
14	{
15	freehttpd_response_t *response = calloc (1, sizeof (freehttpd_response_t));
16
17	if (response == NULL)
18	return NULL;
19
20	response->stream = stream;
21	response->version = version == NULL ? NULL : strdup (version);
22	response->version_length = version == NULL ? 0
23	: version_len == 0 ? strlen (version)
24	: version_len;
25	response->status.code = status;
26	response->status.text
27	= status != 0 ? freehttpd_response_status_text (status) : NULL;
28	response->status.status_text_length = 0;
29	response->headers = NULL;
30	response->headers_length = 0;
31	response->buffer = NULL;
32	response->buffer_length = 0;
33
34	return response;
35	}
36
37	const char *
38	freehttpd_response_status_text (freehttpd_status_t status)
39	{
40	switch (status)
41	{
42	case FREEHTTPD_STATUS_OK:
43	return "OK";
44	case FREEHTTPD_STATUS_BAD_REQUEST:
45	return "Bad Request";
46	case FREEHTTPD_STATUS_NOT_FOUND:
47	return "Not Found";
48	case FREEHTTPD_STATUS_METHOD_NOT_ALLOWED:
49	return "Method Not Allowed";
50	case FREEHTTPD_STATUS_INTERNAL_SERVER_ERROR:
51	return "Internal Server Error";
52	case FREEHTTPD_STATUS_NOT_IMPLEMENTED:
53	return "Not Implemented";
54	case FREEHTTPD_STATUS_FORBIDDEN:
55	return "Forbidden";
56	default:
57	return "Unknown Status";
58	}
59	}
60
61	const char *
62	freehttpd_response_status_description (freehttpd_status_t status)
63	{
64	switch (status)
65	{
66	case FREEHTTPD_STATUS_BAD_REQUEST:
67	return "Your browser sent a request that this server could not "
68	"understand.";
69	case FREEHTTPD_STATUS_NOT_FOUND:
70	return "The requested URL was not found on this server.";
71	case FREEHTTPD_STATUS_METHOD_NOT_ALLOWED:
72	return "The requested method is not allowed for the URL.";
73	case FREEHTTPD_STATUS_NOT_IMPLEMENTED:
74	return "The server does not support the action requested by the "
75	"browser.";
76	case FREEHTTPD_STATUS_FORBIDDEN:
77	return "You don't have permission to access the requested URL on "
78	"this server.";
79	default:
80	return "The server encountered an internal error or "
81	"misconfiguration and was unable to complete your request.";
82	}
83	}
84
85	void
86	freehttpd_response_set_status (freehttpd_response_t *response,
87	freehttpd_status_t status)
88	{
89	response->status.code = status;
90	response->status.text = freehttpd_response_status_text (status);
91	}
92
93	void
94	freehttpd_response_add_default_headers (freehttpd_response_t *response)
95	{
96	response->headers
97	= realloc (response->headers, sizeof (freehttpd_header_t)
98	* (response->headers_length + 3));
99	response->headers[response->headers_length++]
100	= freehttpd_header_init_stack ("Server", "freehttpd", 6, 9);
101	response->headers[response->headers_length++]
102	= freehttpd_header_init_stack ("Connection", "close", 10, 5);
103
104	struct tm *time_info;
105	time_t raw_time;
106	time (&raw_time);
107	time_info = gmtime (&raw_time);
108
109	char time_str[64];
110	size_t time_strlen = strftime (time_str, sizeof (time_str),
111	"%a, %d %b %Y %H:%M:%S GMT", time_info);
112
113	response->headers[response->headers_length++]
114	= freehttpd_header_init_stack ("Date", time_str, 4, time_strlen);
115	}
116
117	freehttpd_header_t *
118	freehttpd_response_add_header (freehttpd_response_t response, const char name,
119	size_t name_len, const char *value_fmt, ...)
120	{
121	va_list args;
122	char *final_value = NULL;
123	freehttpd_header_t *header;
124
125	va_start (args, value_fmt);
126	(void) (vasprintf (&final_value, value_fmt, args) + 1);
127	va_end (args);
128
129	response->headers
130	= realloc (response->headers, sizeof (freehttpd_header_t)
131	* (response->headers_length + 1));
132	response->headers[response->headers_length++]
133	= freehttpd_header_init_stack (name, NULL, name_len, 0);
134
135	header = &response->headers[response->headers_length - 1];
136	header->value = final_value;
137	header->value_length = strlen (final_value);
138
139	return response->headers + (response->headers_length - 1);
140	}
141
142	ecode_t
143	freehttpd_response_head_send (const freehttpd_response_t *response)
144	{
145	int ret = 0;
146
147	ret = fprintf (response->stream, "HTTP/%s %d %s\r\n", response->version,
148	response->status.code, response->status.text);
149
150	if (ret < 0)
151	return E_SYSCALL_WRITE;
152
153	for (size_t i = 0; i < response->headers_length; i++)
154	{
155	ret = fprintf (response->stream, "%s: %s\r\n",
156	response->headers[i].name,
157	response->headers[i].value);
158
159	if (ret < 0)
160	return E_SYSCALL_WRITE;
161	}
162
163	fflush (response->stream);
164	return E_OK;
165	}
166
167	ecode_t
168	freehttpd_response_begin_body (freehttpd_response_t *response)
169	{
170	if (fwrite ("\r\n", 1, 2, response->stream) != 2)
171	return E_SYSCALL_WRITE;
172
173	fflush (response->stream);
174	return E_OK;
175	}
176
177	ecode_t
178	freehttpd_response_begin_end (freehttpd_response_t *response)
179	{
180	return freehttpd_response_begin_body (response);
181	}
182
183	size_t
184	freehttpd_response_write (freehttpd_response_t response, const void data,
185	size_t size, size_t n)
186	{
187	size_t wsize = fwrite (data, size, n, response->stream);
188
189	if (wsize > 0)
190	{
191	int old_errno = errno;
192	fflush (response->stream);
193	errno = old_errno;
194	}
195
196	return wsize;
197	}
198
199	ecode_t
200	freehttpd_response_printf (freehttpd_response_t response, const char format,
201	...)
202	{
203	va_list args;
204	va_start (args, format);
205	int ret = vfprintf (response->stream, format, args);
206	va_end (args);
207
208	if (ret < 0)
209	return E_SYSCALL_WRITE;
210
211	return E_OK;
212	}
213
214	ecode_t
215	freehttpd_response_bprintf (freehttpd_response_t response, const char format,
216	...)
217	{
218	va_list args;
219	va_start (args, format);
220	char *str = NULL;
221	int ret = vasprintf (&str, format, args);
222	va_end (args);
223
224	if (ret < 0)
225	return E_SYSCALL_WRITE;
226
227	size_t new_len = strlen (str) + 1;
228	response->buffer_length += new_len;
229	response->buffer = realloc (response->buffer, response->buffer_length);
230	memcpy (response->buffer + response->buffer_length - new_len, str, new_len);
231	free (str);
232
233	return E_OK;
234	}
235
236	ecode_t
237	freehttpd_response_flush (freehttpd_response_t *response)
238	{
239	if (response->buffer == NULL)
240	return E_OK;
241
242	size_t written = 0;
243
244	while (written < response->buffer_length)
245	{
246	ssize_t ret
247	= fwrite (response->buffer + written, 1,
248	response->buffer_length - written, response->stream);
249
250	if (ret < 0)
251	return E_SYSCALL_WRITE;
252
253	written += ret;
254	}
255
256	fflush (response->stream);
257	free (response->buffer);
258	response->buffer = NULL;
259	response->buffer_length = 0;
260
261	return E_OK;
262	}
263
264	void
265	freehttpd_response_free (freehttpd_response_t *response)
266	{
267	if (response == NULL)
268	return;
269
270	if (response->version != NULL)
271	free (response->version);
272
273	if (response->headers != NULL)
274	{
275	for (size_t i = 0; i < response->headers_length; i++)
276	{
277	free (response->headers[i].name);
278	free (response->headers[i].value);
279	}
280	}
281
282	free (response->buffer);
283	free (response);
284	}