trunk/freehttpd/request.c

#include "request.h"
#include "freehttpd.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.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)
{
    freehttpd_header_t *header = calloc (1, sizeof (freehttpd_header_t));

    if (header == NULL)
        return NULL;

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

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

    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);

    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);
}

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;

            while (read (sockfd, &c, 1) == 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;
        }

    *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			#include <unistd.h>
8
9			freehttpd_request_t *
10			freehttpd_request_init (const char method, const char uri,
11			const char *version)
12			{
13			freehttpd_request_t *request = calloc (1, sizeof (freehttpd_request_t));
14
15			if (request == NULL)
16			return NULL;
17
18			if (method != NULL)
19			{
20			request->method = strdup (method);
21			request->method_length = strlen (method);
22			}
23
24			if (uri != NULL)
25			{
26			request->uri = strdup (uri);
27			request->uri_length = strlen (uri);
28			}
29
30			if (version != NULL)
31			{
32
33			request->version = strdup (version);
34			request->version_length = strlen (version);
35			}
36
37			return request;
38			}
39
40			freehttpd_header_t *
41			freehttpd_header_init (const char name, const char value)
42			{
43			freehttpd_header_t *header = calloc (1, sizeof (freehttpd_header_t));
44
45			if (header == NULL)
46			return NULL;
47
48			if (name != NULL)
49			header->name = strdup (name);
50
51			if (value != NULL)
52			header->value = strdup (value);
53
54			return header;
55			}
56
57			void
58			freehttpd_header_free (freehttpd_header_t *header)
59			{
60			if (header == NULL)
61			return;
62
63			if (header->name != NULL)
64			free (header->name);
65
66			if (header->value != NULL)
67			free (header->value);
68
69			free (header);
70			}
71
72			void
73			freehttpd_request_free (freehttpd_request_t *request)
74			{
75			if (request == NULL)
76			return;
77
78			if (request->method != NULL)
79			free (request->method);
80
81			if (request->uri != NULL)
82			free (request->uri);
83
84			if (request->version != NULL)
85			free (request->version);
86
87			if (request->headers != NULL)
88			{
89			for (size_t i = 0; i < request->headers_count; i++)
90			freehttpd_header_free (request->headers[i]);
91
92			free (request->headers);
93			}
94
95			if (request->body != NULL)
96			free (request->body);
97
98			free (request);
99			}
100
101			const char *const SUPPORTED_METHODS[]
102			= { "GET", "POST", "PUT", "DELETE", "HEAD",
103			"OPTIONS", "TRACE", "CONNECT", NULL };
104
105			freehttpd_request_t *
106			freehttpd_request_parse (freehttpd_t freehttpd, int sockfd, ecode_t error)
107			{
108			freehttpd_request_t *request = freehttpd_request_init (NULL, NULL, NULL);
109
110			if (request == NULL)
111			{
112			*error = E_LIBC_MALLOC;
113			return NULL;
114			}
115
116			const freehttpd_config_t *config = freehttpd_get_config (freehttpd);
117			char *buf[3] = { 0 };
118			char **buf_ptrs[] = { &request->method, &request->uri, &request->version };
119			size_t max_lengths[] = { config->max_method_len, config->max_uri_len,
120			config->max_version_len };
121			size_t *length_ptrs[] = { &request->method_length, &request->uri_length,
122			&request->version_length };
123
124			for (int i = 0; i < 3; i++)
125			{
126			char c;
127			size_t j = 0;
128
129			while (read (sockfd, &c, 1) == 1)
130			{
131			if (isspace (c))
132			break;
133
134			if (j >= max_lengths[i])
135			{
136			freehttpd_request_free (request);
137			*error = E_MALFORMED_REQUEST;
138			return NULL;
139			}
140
141			buf[i] = realloc (buf[i], j + 1);
142			buf[i][j++] = c;
143			}
144
145			if (j == 0)
146			{
147			freehttpd_request_free (request);
148			*error = E_MALFORMED_REQUEST;
149			return NULL;
150			}
151
152			buf[i] = realloc (buf[i], j + 1);
153			buf[i][j] = 0;
154			*length_ptrs[i] = j;
155			*buf_ptrs[i] = buf[i];
156			}
157
158			for (size_t i = 0; SUPPORTED_METHODS[i] != NULL; i++)
159			{
160			if (strcmp (buf[0], SUPPORTED_METHODS[i]) == 0)
161			{
162			request->method = buf[0];
163			break;
164			}
165			}
166
167			if (request->method == NULL \|\| request->uri == NULL
168			\|\| request->version == NULL)
169			{
170			freehttpd_request_free (request);
171			*error = E_MALFORMED_REQUEST;
172			return NULL;
173			}
174
175			*error = E_OK;
176			return request;
177			}