trunk/freehttpd/freehttpd.c

#include "freehttpd.h"
#include "request.h"
#include <arpa/inet.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

struct freehttpd
{
    int sockfd;
    freehttpd_config_t *config;
};

static freehttpd_config_t *
freehttpd_config_init ()
{
    struct freehttpd_config *config = calloc (1, sizeof (freehttpd_config_t));

    if (config == NULL)
        return NULL;

    config->port = 80;
    config->addr = NULL;
    config->max_listen_queue = 5;
    config->max_method_len = 16;
    config->max_uri_len = 8192;
    config->max_version_len = 16;

    return config;
}

static void
freehttpd_config_free (freehttpd_config_t *config)
{
    if (config == NULL)
        return;

    free (config->addr);
    free (config);
}

freehttpd_t *
freehttpd_init ()
{
    freehttpd_t *freehttpd = calloc (1, sizeof (freehttpd_t));

    if (freehttpd == NULL)
        return NULL;

    freehttpd->sockfd = -1;
    freehttpd->config = freehttpd_config_init ();
    return freehttpd;
}

ecode_t
freehttpd_setopt (freehttpd_t *freehttpd, freehttpd_opt_t opt, void *value)
{
    if (opt >= CONFIG_OPTION_COUNT)
        return E_UNKNOWN_OPT;

    switch (opt)
        {
        case FREEHTTPD_CONFIG_PORT:
            freehttpd->config->port = *(unsigned int *) value;
            break;

        case FREEHTTPD_CONFIG_ADDR:
            freehttpd->config->addr
                = value == NULL ? NULL : strdup ((const char *) value);
            break;

        case FREEHTTPD_CONFIG_MAX_LISTEN_QUEUE:
            freehttpd->config->max_listen_queue = *(unsigned int *) value;
            break;

        case FREEHTTPD_CONFIG_MAX_METHOD_LEN:
            freehttpd->config->max_method_len = *(size_t *) value;
            break;

        case FREEHTTPD_CONFIG_MAX_URI_LEN:
            freehttpd->config->max_uri_len = *(size_t *) value;
            break;

        case FREEHTTPD_CONFIG_MAX_VERSION_LEN:
            freehttpd->config->max_version_len = *(size_t *) value;
            break;

        default:
            return E_UNKNOWN_OPT;
        }

    return E_OK;
}

void
freehttpd_free (freehttpd_t *freehttpd)
{
    if (freehttpd == NULL)
        return;

    freehttpd_config_free (freehttpd->config);
    free (freehttpd);
}

static ecode_t
freehttpd_create_socket (freehttpd_t *freehttpd)
{
    int sockfd = socket (AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0)
        return E_SYSCALL_SOCKET;

    int opt = 1;

    if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
        return E_SYSCALL_SETSOCKOPT;

    freehttpd->sockfd = sockfd;
    return E_OK;
}

static struct sockaddr_in
freehttpd_setup_addrinfo (freehttpd_t *freehttpd)
{
    struct sockaddr_in addr = { 0 };
    const char *addr_host = freehttpd->config->addr;

    addr.sin_family = AF_INET;
    addr.sin_port = htons (freehttpd->config->port);
    addr.sin_addr.s_addr
        = addr_host == NULL ? INADDR_ANY : inet_addr (addr_host);

    return addr;
}

static ecode_t
freehttpd_bind (freehttpd_t *freehttpd, struct sockaddr_in *addr_in)
{
    if (bind (freehttpd->sockfd, (struct sockaddr *) addr_in, sizeof (*addr_in))
        < 0)
        return E_SYSCALL_BIND;

    return E_OK;
}

static ecode_t
freehttpd_listen (freehttpd_t *freehttpd)
{
    unsigned int max_listen_queue = freehttpd->config->max_listen_queue;

    if (listen (freehttpd->sockfd, (int) max_listen_queue) < 0)
        return E_SYSCALL_LISTEN;

    return E_OK;
}

static ecode_t
freehttpd_loop (freehttpd_t *freehttpd)
{
    while (true)
        {
            struct sockaddr_in client_addr = { 0 };
            socklen_t client_addr_len = sizeof (client_addr);
            int client_sockfd
                = accept (freehttpd->sockfd, (struct sockaddr *) &client_addr,
                          &client_addr_len);

            if (client_sockfd < 0)
                return E_SYSCALL_ACCEPT;

            ecode_t code = E_OK;
            freehttpd_request_t *request
                = freehttpd_request_parse (freehttpd, client_sockfd, &code);

            if (code != E_OK)
                {
                    close (client_sockfd);
                    continue;
                }

            fprintf (stdout, "Incoming: %s %s %s\n", request->method,
                     request->uri, request->version);

            FILE *client = fdopen (client_sockfd, "w");

            if (client == NULL)
                {
                    freehttpd_request_free (request);
                    continue;
                }

            fprintf (client, "%s 200 OK\r\n", request->version);
            fprintf (client, "Server: FreeHTTPD\r\n");
            fprintf (client, "Content-Type: text/html; charset=\"utf-8\"\r\n");
            fprintf (client, "Content-Length: 24\r\n");
            fprintf (client, "Connection: close\r\n");
            fprintf (client, "\r\n");
            fprintf (client, "<h1>Hello, World!</h1>\r\n");
            fflush (client);
            freehttpd_request_free (request);
            fclose (client);
        }

    return E_OK;
}

ecode_t
freehttpd_start (freehttpd_t *restrict freehttpd)
{
    ecode_t code = E_OK;
    struct sockaddr_in addr_in;

    if ((code = freehttpd_create_socket (freehttpd)) != E_OK)
        return code;

    addr_in = freehttpd_setup_addrinfo (freehttpd);

    if ((code = freehttpd_bind (freehttpd, &addr_in)) != E_OK)
        return code;

    if ((code = freehttpd_listen (freehttpd)) != E_OK)
        return code;

    return freehttpd_loop (freehttpd);
}

const freehttpd_config_t *
freehttpd_get_config (freehttpd_t *freehttpd)
{
    return freehttpd->config;
}
1	#include "freehttpd.h"
2	#include "request.h"
3	#include <arpa/inet.h>
4	#include <stdbool.h>
5	#include <stdint.h>
6	#include <stdio.h>
7	#include <stdlib.h>
8	#include <string.h>
9	#include <sys/socket.h>
10	#include <sys/types.h>
11	#include <unistd.h>
12
13	struct freehttpd
14	{
15	int sockfd;
16	freehttpd_config_t *config;
17	};
18
19	static freehttpd_config_t *
20	freehttpd_config_init ()
21	{
22	struct freehttpd_config *config = calloc (1, sizeof (freehttpd_config_t));
23
24	if (config == NULL)
25	return NULL;
26
27	config->port = 80;
28	config->addr = NULL;
29	config->max_listen_queue = 5;
30	config->max_method_len = 16;
31	config->max_uri_len = 8192;
32	config->max_version_len = 16;
33
34	return config;
35	}
36
37	static void
38	freehttpd_config_free (freehttpd_config_t *config)
39	{
40	if (config == NULL)
41	return;
42
43	free (config->addr);
44	free (config);
45	}
46
47	freehttpd_t *
48	freehttpd_init ()
49	{
50	freehttpd_t *freehttpd = calloc (1, sizeof (freehttpd_t));
51
52	if (freehttpd == NULL)
53	return NULL;
54
55	freehttpd->sockfd = -1;
56	freehttpd->config = freehttpd_config_init ();
57	return freehttpd;
58	}
59
60	ecode_t
61	freehttpd_setopt (freehttpd_t freehttpd, freehttpd_opt_t opt, void value)
62	{
63	if (opt >= CONFIG_OPTION_COUNT)
64	return E_UNKNOWN_OPT;
65
66	switch (opt)
67	{
68	case FREEHTTPD_CONFIG_PORT:
69	freehttpd->config->port = (unsigned int ) value;
70	break;
71
72	case FREEHTTPD_CONFIG_ADDR:
73	freehttpd->config->addr
74	= value == NULL ? NULL : strdup ((const char *) value);
75	break;
76
77	case FREEHTTPD_CONFIG_MAX_LISTEN_QUEUE:
78	freehttpd->config->max_listen_queue = (unsigned int ) value;
79	break;
80
81	case FREEHTTPD_CONFIG_MAX_METHOD_LEN:
82	freehttpd->config->max_method_len = (size_t ) value;
83	break;
84
85	case FREEHTTPD_CONFIG_MAX_URI_LEN:
86	freehttpd->config->max_uri_len = (size_t ) value;
87	break;
88
89	case FREEHTTPD_CONFIG_MAX_VERSION_LEN:
90	freehttpd->config->max_version_len = (size_t ) value;
91	break;
92
93	default:
94	return E_UNKNOWN_OPT;
95	}
96
97	return E_OK;
98	}
99
100	void
101	freehttpd_free (freehttpd_t *freehttpd)
102	{
103	if (freehttpd == NULL)
104	return;
105
106	freehttpd_config_free (freehttpd->config);
107	free (freehttpd);
108	}
109
110	static ecode_t
111	freehttpd_create_socket (freehttpd_t *freehttpd)
112	{
113	int sockfd = socket (AF_INET, SOCK_STREAM, 0);
114
115	if (sockfd < 0)
116	return E_SYSCALL_SOCKET;
117
118	int opt = 1;
119
120	if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
121	return E_SYSCALL_SETSOCKOPT;
122
123	freehttpd->sockfd = sockfd;
124	return E_OK;
125	}
126
127	static struct sockaddr_in
128	freehttpd_setup_addrinfo (freehttpd_t *freehttpd)
129	{
130	struct sockaddr_in addr = { 0 };
131	const char *addr_host = freehttpd->config->addr;
132
133	addr.sin_family = AF_INET;
134	addr.sin_port = htons (freehttpd->config->port);
135	addr.sin_addr.s_addr
136	= addr_host == NULL ? INADDR_ANY : inet_addr (addr_host);
137
138	return addr;
139	}
140
141	static ecode_t
142	freehttpd_bind (freehttpd_t freehttpd, struct sockaddr_in addr_in)
143	{
144	if (bind (freehttpd->sockfd, (struct sockaddr ) addr_in, sizeof (addr_in))
145	< 0)
146	return E_SYSCALL_BIND;
147
148	return E_OK;
149	}
150
151	static ecode_t
152	freehttpd_listen (freehttpd_t *freehttpd)
153	{
154	unsigned int max_listen_queue = freehttpd->config->max_listen_queue;
155
156	if (listen (freehttpd->sockfd, (int) max_listen_queue) < 0)
157	return E_SYSCALL_LISTEN;
158
159	return E_OK;
160	}
161
162	static ecode_t
163	freehttpd_loop (freehttpd_t *freehttpd)
164	{
165	while (true)
166	{
167	struct sockaddr_in client_addr = { 0 };
168	socklen_t client_addr_len = sizeof (client_addr);
169	int client_sockfd
170	= accept (freehttpd->sockfd, (struct sockaddr *) &client_addr,
171	&client_addr_len);
172
173	if (client_sockfd < 0)
174	return E_SYSCALL_ACCEPT;
175
176	ecode_t code = E_OK;
177	freehttpd_request_t *request
178	= freehttpd_request_parse (freehttpd, client_sockfd, &code);
179
180	if (code != E_OK)
181	{
182	close (client_sockfd);
183	continue;
184	}
185
186	fprintf (stdout, "Incoming: %s %s %s\n", request->method,
187	request->uri, request->version);
188
189	FILE *client = fdopen (client_sockfd, "w");
190
191	if (client == NULL)
192	{
193	freehttpd_request_free (request);
194	continue;
195	}
196
197	fprintf (client, "%s 200 OK\r\n", request->version);
198	fprintf (client, "Server: FreeHTTPD\r\n");
199	fprintf (client, "Content-Type: text/html; charset=\"utf-8\"\r\n");
200	fprintf (client, "Content-Length: 24\r\n");
201	fprintf (client, "Connection: close\r\n");
202	fprintf (client, "\r\n");
203	fprintf (client, "<h1>Hello, World!</h1>\r\n");
204	fflush (client);
205	freehttpd_request_free (request);
206	fclose (client);
207	}
208
209	return E_OK;
210	}
211
212	ecode_t
213	freehttpd_start (freehttpd_t *restrict freehttpd)
214	{
215	ecode_t code = E_OK;
216	struct sockaddr_in addr_in;
217
218	if ((code = freehttpd_create_socket (freehttpd)) != E_OK)
219	return code;
220
221	addr_in = freehttpd_setup_addrinfo (freehttpd);
222
223	if ((code = freehttpd_bind (freehttpd, &addr_in)) != E_OK)
224	return code;
225
226	if ((code = freehttpd_listen (freehttpd)) != E_OK)
227	return code;
228
229	return freehttpd_loop (freehttpd);
230	}
231
232	const freehttpd_config_t *
233	freehttpd_get_config (freehttpd_t *freehttpd)
234	{
235	return freehttpd->config;
236	}