trunk/freehttpd/request.c

#include "request.h"
#include "freehttpd.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

freehttpd_request_t *
freehttpd_request_init (const char *method, const char *uri,
                        const char *version)
{
    freehttpd_request_t *request = calloc (1, sizeof (freehttpd_request_t));

    if (request == NULL)
        return NULL;

    if (method != NULL)
        {
            request->method = strdup (method);
            request->method_length = strlen (method);
        }

    if (uri != NULL)
        {
            request->uri = strdup (uri);
            request->uri_length = strlen (uri);
        }

    if (version != NULL)
        {

            request->version = strdup (version);
            request->version_length = strlen (version);
        }

    return request;
}

freehttpd_header_t *
freehttpd_header_init (const char *name, const char *value, size_t name_length,
                       size_t value_length)
{
    freehttpd_header_t *header = calloc (1, sizeof (freehttpd_header_t));

    if (header == NULL)
        return NULL;

    if (name != NULL)
        {
            header->name = strdup (name);
            header->name_length
                = name_length == 0 ? strlen (name) : name_length;
        }

    if (value != NULL)
        {
            header->value = strdup (value);
            header->value_length
                = value_length == 0 ? strlen (value) : value_length;
        }

    return header;
}

void
freehttpd_header_free (freehttpd_header_t *header)
{
    if (header == NULL)
        return;

    if (header->name != NULL)
        free (header->name);

    if (header->value != NULL)
        free (header->value);

    free (header);
}

void
freehttpd_request_free (freehttpd_request_t *request)
{
    if (request == NULL)
        return;

    if (request->method != NULL)
        free (request->method);

    if (request->uri != NULL)
        free (request->uri);

    if (request->version != NULL)
        free (request->version - 5);

    if (request->path != NULL)
        free (request->path);

    if (request->query != NULL)
        free (request->query);

    if (request->headers != NULL)
        {
            for (size_t i = 0; i < request->headers_count; i++)
                freehttpd_header_free (request->headers[i]);

            free (request->headers);
        }

    if (request->body != NULL)
        free (request->body);

    free (request);
}

static char *
urldecode (const char *input, size_t *len)
{
    char *output = calloc (strlen (input) + 1, 1);

    if (output == NULL)
        return NULL;

    size_t i = 0, j = 0;

    for (; input[i] != 0; i++, j++)
        {
            if (input[i] == '%')
                {
                    if (input[i + 1] == 0 || input[i + 2] == 0)
                        {
                            free (output);
                            return NULL;
                        }

                    char c1 = tolower (input[i + 1]);
                    char c2 = tolower (input[i + 2]);
                    int c1n = isdigit (c1) ? c1 - '0' : c1 - 'a' + 10;
                    int c2n = isdigit (c2) ? c2 - '0' : c2 - 'a' + 10;
                    int code = c1n * 16 + c2n;
                    output[j] = (char) code;
                    i += 2;
                }
            else
                output[j] = input[i];
        }

    output[j] = 0;

    printf ("output: %s\n", output);

    if (len != NULL)
        *len = j;

    return output;
}

const char *const SUPPORTED_METHODS[]
    = { "GET",     "POST",  "PUT",     "DELETE", "HEAD",
        "OPTIONS", "TRACE", "CONNECT", NULL };

freehttpd_request_t *
freehttpd_request_parse (freehttpd_t *freehttpd, int sockfd, ecode_t *error)
{
    freehttpd_request_t *request = freehttpd_request_init (NULL, NULL, NULL);

    if (request == NULL)
        {
            *error = E_LIBC_MALLOC;
            return NULL;
        }

    const freehttpd_config_t *config = freehttpd_get_config (freehttpd);
    char *buf[3] = { 0 };
    char **buf_ptrs[] = { &request->method, &request->uri, &request->version };
    size_t max_lengths[] = { config->max_method_len, config->max_uri_len,
                             config->max_version_len };
    size_t *length_ptrs[] = { &request->method_length, &request->uri_length,
                              &request->version_length };

    for (int i = 0; i < 3; i++)
        {
            char c;
            size_t j = 0;

            /* TODO: instead of always calling read with size 1, we could
               optimize this by reading more bytes at once and then parsing
               the buffer. */
            while (recv (sockfd, &c, 1, 0) == 1)
                {
                    if (isspace (c))
                        break;

                    if (j >= max_lengths[i])
                        {
                            freehttpd_request_free (request);
                            *error = E_MALFORMED_REQUEST;
                            return NULL;
                        }

                    buf[i] = realloc (buf[i], j + 1);
                    buf[i][j++] = c;
                }

            if (j == 0)
                {
                    freehttpd_request_free (request);
                    *error = E_MALFORMED_REQUEST;
                    return NULL;
                }

            buf[i] = realloc (buf[i], j + 1);
            buf[i][j] = 0;
            *length_ptrs[i] = j;
            *buf_ptrs[i] = buf[i];
        }

    for (size_t i = 0; SUPPORTED_METHODS[i] != NULL; i++)
        {
            if (strcmp (buf[0], SUPPORTED_METHODS[i]) == 0)
                {
                    request->method = buf[0];
                    break;
                }
        }

    if (request->method == NULL || request->uri == NULL
        || request->version == NULL)
        {
            freehttpd_request_free (request);
            *error = E_MALFORMED_REQUEST;
            return NULL;
        }

    if (memcmp (request->version, "HTTP/", 5) != 0)
        {
            freehttpd_request_free (request);
            *error = E_MALFORMED_REQUEST;
            return NULL;
        }

    request->version += 5;
    request->version_length -= 5;

    char *path = strchr (request->uri, '?');

    if (path != NULL)
        {
            path = strndup (request->uri, path - request->uri);
            request->query = strdup (path + 1);
            request->query_length
                = request->uri_length - request->path_length - 1;
        }
    else
        path = strdup (request->uri);

    request->path = urldecode (path, &request->path_length);
    free (path);
    *error = E_OK;
    return request;
}
1	rakinar2	44	#include "request.h"
2			#include "freehttpd.h"
3			#include <ctype.h>
4			#include <stdio.h>
5			#include <stdlib.h>
6			#include <string.h>
7	rakinar2	45	#include <sys/socket.h>
8	rakinar2	44	#include <unistd.h>
9
10			freehttpd_request_t *
11			freehttpd_request_init (const char method, const char uri,
12			const char *version)
13			{
14			freehttpd_request_t *request = calloc (1, sizeof (freehttpd_request_t));
15
16			if (request == NULL)
17			return NULL;
18
19			if (method != NULL)
20			{
21			request->method = strdup (method);
22			request->method_length = strlen (method);
23			}
24
25			if (uri != NULL)
26			{
27			request->uri = strdup (uri);
28			request->uri_length = strlen (uri);
29			}
30
31			if (version != NULL)
32			{
33
34			request->version = strdup (version);
35			request->version_length = strlen (version);
36			}
37
38			return request;
39			}
40
41			freehttpd_header_t *
42	rakinar2	45	freehttpd_header_init (const char name, const char value, size_t name_length,
43			size_t value_length)
44	rakinar2	44	{
45			freehttpd_header_t *header = calloc (1, sizeof (freehttpd_header_t));
46
47			if (header == NULL)
48			return NULL;
49
50			if (name != NULL)
51	rakinar2	45	{
52			header->name = strdup (name);
53			header->name_length
54			= name_length == 0 ? strlen (name) : name_length;
55			}
56	rakinar2	44
57			if (value != NULL)
58	rakinar2	45	{
59			header->value = strdup (value);
60			header->value_length
61			= value_length == 0 ? strlen (value) : value_length;
62			}
63	rakinar2	44
64			return header;
65			}
66
67			void
68			freehttpd_header_free (freehttpd_header_t *header)
69			{
70			if (header == NULL)
71			return;
72
73			if (header->name != NULL)
74			free (header->name);
75
76			if (header->value != NULL)
77			free (header->value);
78
79			free (header);
80			}
81
82			void
83			freehttpd_request_free (freehttpd_request_t *request)
84			{
85			if (request == NULL)
86			return;
87
88			if (request->method != NULL)
89			free (request->method);
90
91			if (request->uri != NULL)
92			free (request->uri);
93
94			if (request->version != NULL)
95	rakinar2	45	free (request->version - 5);
96	rakinar2	44
97	rakinar2	45	if (request->path != NULL)
98			free (request->path);
99
100			if (request->query != NULL)
101			free (request->query);
102
103	rakinar2	44	if (request->headers != NULL)
104			{
105			for (size_t i = 0; i < request->headers_count; i++)
106			freehttpd_header_free (request->headers[i]);
107
108			free (request->headers);
109			}
110
111			if (request->body != NULL)
112			free (request->body);
113
114			free (request);
115			}
116
117	rakinar2	45	static char *
118			urldecode (const char input, size_t len)
119			{
120			char *output = calloc (strlen (input) + 1, 1);
121
122			if (output == NULL)
123			return NULL;
124
125			size_t i = 0, j = 0;
126
127			for (; input[i] != 0; i++, j++)
128			{
129			if (input[i] == '%')
130			{
131			if (input[i + 1] == 0 \|\| input[i + 2] == 0)
132			{
133			free (output);
134			return NULL;
135			}
136
137			char c1 = tolower (input[i + 1]);
138			char c2 = tolower (input[i + 2]);
139			int c1n = isdigit (c1) ? c1 - '0' : c1 - 'a' + 10;
140			int c2n = isdigit (c2) ? c2 - '0' : c2 - 'a' + 10;
141			int code = c1n * 16 + c2n;
142			output[j] = (char) code;
143			i += 2;
144			}
145			else
146			output[j] = input[i];
147			}
148
149			output[j] = 0;
150
151			printf ("output: %s\n", output);
152
153			if (len != NULL)
154			*len = j;
155
156			return output;
157			}
158
159	rakinar2	44	const char *const SUPPORTED_METHODS[]
160			= { "GET", "POST", "PUT", "DELETE", "HEAD",
161			"OPTIONS", "TRACE", "CONNECT", NULL };
162
163			freehttpd_request_t *
164			freehttpd_request_parse (freehttpd_t freehttpd, int sockfd, ecode_t error)
165			{
166			freehttpd_request_t *request = freehttpd_request_init (NULL, NULL, NULL);
167
168			if (request == NULL)
169			{
170			*error = E_LIBC_MALLOC;
171			return NULL;
172			}
173
174			const freehttpd_config_t *config = freehttpd_get_config (freehttpd);
175			char *buf[3] = { 0 };
176			char **buf_ptrs[] = { &request->method, &request->uri, &request->version };
177			size_t max_lengths[] = { config->max_method_len, config->max_uri_len,
178			config->max_version_len };
179			size_t *length_ptrs[] = { &request->method_length, &request->uri_length,
180			&request->version_length };
181
182			for (int i = 0; i < 3; i++)
183			{
184			char c;
185			size_t j = 0;
186
187	rakinar2	45	/* TODO: instead of always calling read with size 1, we could
188			optimize this by reading more bytes at once and then parsing
189			the buffer. */
190			while (recv (sockfd, &c, 1, 0) == 1)
191	rakinar2	44	{
192			if (isspace (c))
193			break;
194
195			if (j >= max_lengths[i])
196			{
197			freehttpd_request_free (request);
198			*error = E_MALFORMED_REQUEST;
199			return NULL;
200			}
201
202			buf[i] = realloc (buf[i], j + 1);
203			buf[i][j++] = c;
204			}
205
206			if (j == 0)
207			{
208			freehttpd_request_free (request);
209			*error = E_MALFORMED_REQUEST;
210			return NULL;
211			}
212
213			buf[i] = realloc (buf[i], j + 1);
214			buf[i][j] = 0;
215			*length_ptrs[i] = j;
216			*buf_ptrs[i] = buf[i];
217			}
218
219			for (size_t i = 0; SUPPORTED_METHODS[i] != NULL; i++)
220			{
221			if (strcmp (buf[0], SUPPORTED_METHODS[i]) == 0)
222			{
223			request->method = buf[0];
224			break;
225			}
226			}
227
228			if (request->method == NULL \|\| request->uri == NULL
229			\|\| request->version == NULL)
230			{
231			freehttpd_request_free (request);
232			*error = E_MALFORMED_REQUEST;
233			return NULL;
234			}
235
236	rakinar2	45	if (memcmp (request->version, "HTTP/", 5) != 0)
237			{
238			freehttpd_request_free (request);
239			*error = E_MALFORMED_REQUEST;
240			return NULL;
241			}
242
243			request->version += 5;
244			request->version_length -= 5;
245
246			char *path = strchr (request->uri, '?');
247
248			if (path != NULL)
249			{
250			path = strndup (request->uri, path - request->uri);
251			request->query = strdup (path + 1);
252			request->query_length
253			= request->uri_length - request->path_length - 1;
254			}
255			else
256			path = strdup (request->uri);
257
258			request->path = urldecode (path, &request->path_length);
259			free (path);
260	rakinar2	44	*error = E_OK;
261			return request;
262			}