hydra/src/config.c

/*
 *  Boa, an http server
 *  Copyright (C) 1999 Larry Doolittle <ldoolitt@boa.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 1, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/* $Id: config.c,v 1.31.2.3 2002/07/26 03:04:29 jnelson Exp $*/

#include "boa.h"
#include "y.tab.h"
#include "parse.h"

int yyparse(void);              /* Better match the output of lex */

#ifdef DEBUG
#define DBG(x) x
#else
#define DBG(x)
#endif

int server_port;
uid_t server_uid;
gid_t server_gid;
char *server_root;
char *server_name;
char *server_admin;
char *server_ip;
int virtualhost;
long int max_connections;

int server_max_threads = 1;

char *server_cert;
char *server_key;
int ssl_session_cache;
int boa_ssl = 0;
int ssl_port = 443;
int ssl_dh_bits = 1024; /* default value */
int ssl_session_timeout = 3600;
int ssl_params_refresh = 432000; /* every 5 days */

char *ssl_ciphers = NULL;
char *ssl_mac = NULL;
char *ssl_kx = NULL;
char *ssl_comp = NULL;
char *ssl_protocol = NULL;

char *document_root;
char *user_dir;
char *directory_index;
char *default_type;
char *dirmaker;
char *cachedir;

char *tempdir;

char *cgi_path = NULL;
int single_post_limit = SINGLE_POST_LIMIT_DEFAULT;

int ka_timeout;
int ka_max;

/* These came from log.c */
char *error_log_name;
char *access_log_name;
char *cgi_log_name;

int use_localtime;

/* These are new */
static void c_set_user(char *v1, char *v2, void *t);
static void c_set_group(char *v1, char *v2, void *t);
static void c_set_string(char *v1, char *v2, void *t);
static void c_set_int(char *v1, char *v2, void *t);
static void c_set_unity(char *v1, char *v2, void *t);
static void c_add_type(char *v1, char *v2, void *t);
static void c_add_alias(char *v1, char *v2, void *t);

/* Fakery to keep the value passed to action() a void *,
   see usage in table and c_add_alias() below */
static int script_number = SCRIPTALIAS;
static int redirect_number = REDIRECT;
static int alias_number = ALIAS;
static uid_t current_uid=0;

/* Help keep the table below compact */
#define S0A STMT_NO_ARGS
#define S1A STMT_ONE_ARG
#define S2A STMT_TWO_ARGS

struct ccommand clist[] = {
    {"SSLCiphers", S1A, c_set_string, &ssl_ciphers},
    {"SSLKeyExchangeAlgorithms", S1A, c_set_string, &ssl_kx},
    {"SSLMACAlgorithms", S1A, c_set_string, &ssl_mac},
    {"SSLProtocols", S1A, c_set_string, &ssl_protocol},
    {"SSLCompressionMethods", S1A, c_set_string, &ssl_comp},
    {"SSLCertificate", S1A, c_set_string, &server_cert},
    {"SSLKey", S1A, c_set_string, &server_key},
    {"SSLSessionCache", S1A, c_set_int, &ssl_session_cache},
    {"SSL", S1A, c_set_int, &boa_ssl},
    {"SSLPort", S1A, c_set_int, &ssl_port},
    {"SSLDHBits", S1A, c_set_int, &ssl_dh_bits},
    {"SSLSessionTimeout", S1A, c_set_int, &ssl_session_timeout},
    {"SSLParamsRefresh", S1A, c_set_int, &ssl_params_refresh},
    {"Threads", S1A, c_set_int, &server_max_threads},
    {"Port", S1A, c_set_int, &server_port},
    {"Listen", S1A, c_set_string, &server_ip},
    {"BackLog", S1A, c_set_int, &backlog},
    {"User", S1A, c_set_user, NULL},
    {"Group", S1A, c_set_group, NULL},
    {"ServerAdmin", S1A, c_set_string, &server_admin},
    {"ServerRoot", S1A, c_set_string, &server_root},
    {"ErrorLog", S1A, c_set_string, &error_log_name},
    {"AccessLog", S1A, c_set_string, &access_log_name},
    {"UseLocaltime", S0A, c_set_unity, &use_localtime},
    {"CgiLog", S1A, c_set_string, &cgi_log_name},
    {"VerboseCGILogs", S0A, c_set_unity, &verbose_cgi_logs},
    {"ServerName", S1A, c_set_string, &server_name},
    {"VirtualHost", S0A, c_set_unity, &virtualhost},
    {"DocumentRoot", S1A, c_set_string, &document_root},
    {"UserDir", S1A, c_set_string, &user_dir},
    {"DirectoryIndex", S1A, c_set_string, &directory_index},
    {"DirectoryMaker", S1A, c_set_string, &dirmaker},
    {"DirectoryCache", S1A, c_set_string, &cachedir},
    {"KeepAliveMax", S1A, c_set_int, &ka_max},
    {"KeepAliveTimeout", S1A, c_set_int, &ka_timeout},
    {"MimeTypes", S1A, c_set_string, &mime_types},
    {"DefaultType", S1A, c_set_string, &default_type},
    {"AddType", S2A, c_add_type, NULL},
    {"ScriptAlias", S2A, c_add_alias, &script_number},
    {"Redirect", S2A, c_add_alias, &redirect_number},
    {"Alias", S2A, c_add_alias, &alias_number},
    {"SinglePostLimit", S1A, c_set_int, &single_post_limit},
    {"CGIPath", S1A, c_set_string, &cgi_path},
    {"MaxConnections", S1A, c_set_int, &max_connections},
};

static void c_set_user(char *v1, char *v2, void *t)
{
    struct passwd *passwdbuf;
    char *endptr;
    int i;

    DBG(printf("User %s = ", v1);
        )
        i = strtol(v1, &endptr, 0);
    if (*v1 != '\0' && *endptr == '\0') {
        server_uid = i;
    } else {
        passwdbuf = getpwnam(v1);
        if (!passwdbuf) {
            if (current_uid)
                return;
            fprintf(stderr, "No such user: %s\n", v1);
            exit(1);
        }
        server_uid = passwdbuf->pw_uid;
    }
    DBG(printf("%d\n", server_uid);
        )
}

static void c_set_group(char *v1, char *v2, void *t)
{
    struct group *groupbuf;
    char *endptr;
    int i;
    DBG(printf("Group %s = ", v1);
        )
        i = strtol(v1, &endptr, 0);
    if (*v1 != '\0' && *endptr == '\0') {
        server_gid = i;
    } else {
        groupbuf = getgrnam(v1);
        if (!groupbuf) {
            if (current_uid)
                return;
            fprintf(stderr, "No such group: %s\n", v1);
            exit(1);
        }
        server_gid = groupbuf->gr_gid;
    }
    DBG(printf("%d\n", server_gid);
        )
}

static void c_set_string(char *v1, char *v2, void *t)
{
    char *s;
    DBG(printf("Setting pointer %p to string %s ..", t, v1);
        )
        if (t) {
        s = *(char **) t;
        if (s)
            free(s);
        *(char **) t = strdup(v1);
        if (!*(char **) t) {
            DIE("Unable to strdup in c_set_string");
        }
        DBG(printf("done.\n");
            )
    } else {
        DBG(printf("skipped.\n");
            )
    }
}

static void c_set_int(char *v1, char *v2, void *t)
{
    char *endptr;
    int i;
    DBG(printf("Setting pointer %p to integer string %s ..", t, v1);
        )
        if (t) {
        i = strtol(v1, &endptr, 0); /* Automatic base 10/16/8 switching */
        if (*v1 != '\0' && *endptr == '\0') {
            *(int *) t = i;
            DBG(printf(" Integer converted as %d, done\n", i);
                )
        } else {
            /* XXX should tell line number to user */
            fprintf(stderr, "Error: %s found where integer expected\n",
                    v1);
        }
    } else {
        DBG(printf("skipped.\n");
            )
    }
}

static void c_set_unity(char *v1, char *v2, void *t)
{
    DBG(printf("Setting pointer %p to unity\n", t);
        )
        if (t)
        *(int *) t = 1;
}

static void c_add_type(char *v1, char *v2, void *t)
{
    add_mime_type(v1, v2);
}

static void c_add_alias(char *v1, char *v2, void *t)
{
    add_alias(v2, v1, *(int *) t);
}

struct ccommand *lookup_keyword(char *c)
{
    struct ccommand *p;
    DBG(printf("Checking string '%s' against keyword list\n", c);
        )
        for (p = clist;
             p < clist + (sizeof (clist) / sizeof (struct ccommand)); p++) {
        if (strcmp(c, p->name) == 0)
            return p;
    }
    return NULL;
}

/*
 * Name: read_config_files
 *
 * Description: Reads config files via yyparse, then makes sure that
 * all required variables were set properly.
 */
void read_config_files(void)
{
    char *temp;
    current_uid = getuid();
    yyin = fopen("boa.conf", "r");

    if (!yyin) {
        fputs("Could not open boa.conf for reading.\n", stderr);
        exit(1);
    }
    if (yyparse()) {
        fputs("Error parsing config files, exiting\n", stderr);
        exit(1);
    }

    if (!server_name) {
        struct hostent *he;
        char temp_name[100];

        if (gethostname(temp_name, 100) == -1) {
            perror("gethostname:");
            exit(1);
        }

        he = gethostbyname(temp_name);
        if (he == NULL) {
            perror("gethostbyname:");
            exit(1);
        }

        server_name = strdup(he->h_name);
        if (server_name == NULL) {
            perror("strdup:");
            exit(1);
        }
    }
    tempdir = getenv("TMP");
    if (tempdir == NULL)
        tempdir = "/tmp";

    if (single_post_limit < 0) {
        fprintf(stderr, "Invalid value for single_post_limit: %d\n",
                single_post_limit);
        exit(1);
    }

    if (document_root) {
        temp = normalize_path(document_root);
        free(document_root);
        document_root = temp;
    }

    if (error_log_name) {
        temp = normalize_path(error_log_name);
        free(error_log_name);
        error_log_name = temp;
    }

    if (access_log_name) {
        temp = normalize_path(access_log_name);
        free(access_log_name);
        access_log_name = temp;
    }

    if (cgi_log_name) {
        temp = normalize_path(cgi_log_name);
        free(cgi_log_name);
        cgi_log_name = temp;
    }

    if (dirmaker) {
        temp = normalize_path(dirmaker);
        free(dirmaker);
        dirmaker = temp;
    }

#if 0
    if (mime_types) {
        temp = normalize_path(mime_types);
        free(mime_types);
        mime_types = temp;
    }
#endif
}
1	/*
2	* Boa, an http server
3	* Copyright (C) 1999 Larry Doolittle <ldoolitt@boa.org>
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 1, or (at your option)
8	* any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18	*
19	*/
20
21	/* $Id: config.c,v 1.31.2.3 2002/07/26 03:04:29 jnelson Exp $*/
22
23	#include "boa.h"
24	#include "y.tab.h"
25	#include "parse.h"
26
27	int yyparse(void); /* Better match the output of lex */
28
29	#ifdef DEBUG
30	#define DBG(x) x
31	#else
32	#define DBG(x)
33	#endif
34
35	int server_port;
36	uid_t server_uid;
37	gid_t server_gid;
38	char *server_root;
39	char *server_name;
40	char *server_admin;
41	char *server_ip;
42	int virtualhost;
43	long int max_connections;
44
45	int server_max_threads = 1;
46
47	char *server_cert;
48	char *server_key;
49	int ssl_session_cache;
50	int boa_ssl = 0;
51	int ssl_port = 443;
52	int ssl_dh_bits = 1024; /* default value */
53	int ssl_session_timeout = 3600;
54	int ssl_params_refresh = 432000; /* every 5 days */
55
56	char *ssl_ciphers = NULL;
57	char *ssl_mac = NULL;
58	char *ssl_kx = NULL;
59	char *ssl_comp = NULL;
60	char *ssl_protocol = NULL;
61
62	char *document_root;
63	char *user_dir;
64	char *directory_index;
65	char *default_type;
66	char *dirmaker;
67	char *cachedir;
68
69	char *tempdir;
70
71	char *cgi_path = NULL;
72	int single_post_limit = SINGLE_POST_LIMIT_DEFAULT;
73
74	int ka_timeout;
75	int ka_max;
76
77	/* These came from log.c */
78	char *error_log_name;
79	char *access_log_name;
80	char *cgi_log_name;
81
82	int use_localtime;
83
84	/* These are new */
85	static void c_set_user(char v1, char v2, void *t);
86	static void c_set_group(char v1, char v2, void *t);
87	static void c_set_string(char v1, char v2, void *t);
88	static void c_set_int(char v1, char v2, void *t);
89	static void c_set_unity(char v1, char v2, void *t);
90	static void c_add_type(char v1, char v2, void *t);
91	static void c_add_alias(char v1, char v2, void *t);
92
93	/* Fakery to keep the value passed to action() a void *,
94	see usage in table and c_add_alias() below */
95	static int script_number = SCRIPTALIAS;
96	static int redirect_number = REDIRECT;
97	static int alias_number = ALIAS;
98	static uid_t current_uid=0;
99
100	/* Help keep the table below compact */
101	#define S0A STMT_NO_ARGS
102	#define S1A STMT_ONE_ARG
103	#define S2A STMT_TWO_ARGS
104
105	struct ccommand clist[] = {
106	{"SSLCiphers", S1A, c_set_string, &ssl_ciphers},
107	{"SSLKeyExchangeAlgorithms", S1A, c_set_string, &ssl_kx},
108	{"SSLMACAlgorithms", S1A, c_set_string, &ssl_mac},
109	{"SSLProtocols", S1A, c_set_string, &ssl_protocol},
110	{"SSLCompressionMethods", S1A, c_set_string, &ssl_comp},
111	{"SSLCertificate", S1A, c_set_string, &server_cert},
112	{"SSLKey", S1A, c_set_string, &server_key},
113	{"SSLSessionCache", S1A, c_set_int, &ssl_session_cache},
114	{"SSL", S1A, c_set_int, &boa_ssl},
115	{"SSLPort", S1A, c_set_int, &ssl_port},
116	{"SSLDHBits", S1A, c_set_int, &ssl_dh_bits},
117	{"SSLSessionTimeout", S1A, c_set_int, &ssl_session_timeout},
118	{"SSLParamsRefresh", S1A, c_set_int, &ssl_params_refresh},
119	{"Threads", S1A, c_set_int, &server_max_threads},
120	{"Port", S1A, c_set_int, &server_port},
121	{"Listen", S1A, c_set_string, &server_ip},
122	{"BackLog", S1A, c_set_int, &backlog},
123	{"User", S1A, c_set_user, NULL},
124	{"Group", S1A, c_set_group, NULL},
125	{"ServerAdmin", S1A, c_set_string, &server_admin},
126	{"ServerRoot", S1A, c_set_string, &server_root},
127	{"ErrorLog", S1A, c_set_string, &error_log_name},
128	{"AccessLog", S1A, c_set_string, &access_log_name},
129	{"UseLocaltime", S0A, c_set_unity, &use_localtime},
130	{"CgiLog", S1A, c_set_string, &cgi_log_name},
131	{"VerboseCGILogs", S0A, c_set_unity, &verbose_cgi_logs},
132	{"ServerName", S1A, c_set_string, &server_name},
133	{"VirtualHost", S0A, c_set_unity, &virtualhost},
134	{"DocumentRoot", S1A, c_set_string, &document_root},
135	{"UserDir", S1A, c_set_string, &user_dir},
136	{"DirectoryIndex", S1A, c_set_string, &directory_index},
137	{"DirectoryMaker", S1A, c_set_string, &dirmaker},
138	{"DirectoryCache", S1A, c_set_string, &cachedir},
139	{"KeepAliveMax", S1A, c_set_int, &ka_max},
140	{"KeepAliveTimeout", S1A, c_set_int, &ka_timeout},
141	{"MimeTypes", S1A, c_set_string, &mime_types},
142	{"DefaultType", S1A, c_set_string, &default_type},
143	{"AddType", S2A, c_add_type, NULL},
144	{"ScriptAlias", S2A, c_add_alias, &script_number},
145	{"Redirect", S2A, c_add_alias, &redirect_number},
146	{"Alias", S2A, c_add_alias, &alias_number},
147	{"SinglePostLimit", S1A, c_set_int, &single_post_limit},
148	{"CGIPath", S1A, c_set_string, &cgi_path},
149	{"MaxConnections", S1A, c_set_int, &max_connections},
150	};
151
152	static void c_set_user(char v1, char v2, void *t)
153	{
154	struct passwd *passwdbuf;
155	char *endptr;
156	int i;
157
158	DBG(printf("User %s = ", v1);
159	)
160	i = strtol(v1, &endptr, 0);
161	if (v1 != '\0' && endptr == '\0') {
162	server_uid = i;
163	} else {
164	passwdbuf = getpwnam(v1);
165	if (!passwdbuf) {
166	if (current_uid)
167	return;
168	fprintf(stderr, "No such user: %s\n", v1);
169	exit(1);
170	}
171	server_uid = passwdbuf->pw_uid;
172	}
173	DBG(printf("%d\n", server_uid);
174	)
175	}
176
177	static void c_set_group(char v1, char v2, void *t)
178	{
179	struct group *groupbuf;
180	char *endptr;
181	int i;
182	DBG(printf("Group %s = ", v1);
183	)
184	i = strtol(v1, &endptr, 0);
185	if (v1 != '\0' && endptr == '\0') {
186	server_gid = i;
187	} else {
188	groupbuf = getgrnam(v1);
189	if (!groupbuf) {
190	if (current_uid)
191	return;
192	fprintf(stderr, "No such group: %s\n", v1);
193	exit(1);
194	}
195	server_gid = groupbuf->gr_gid;
196	}
197	DBG(printf("%d\n", server_gid);
198	)
199	}
200
201	static void c_set_string(char v1, char v2, void *t)
202	{
203	char *s;
204	DBG(printf("Setting pointer %p to string %s ..", t, v1);
205	)
206	if (t) {
207	s = (char *) t;
208	if (s)
209	free(s);
210	(char *) t = strdup(v1);
211	if (!(char *) t) {
212	DIE("Unable to strdup in c_set_string");
213	}
214	DBG(printf("done.\n");
215	)
216	} else {
217	DBG(printf("skipped.\n");
218	)
219	}
220	}
221
222	static void c_set_int(char v1, char v2, void *t)
223	{
224	char *endptr;
225	int i;
226	DBG(printf("Setting pointer %p to integer string %s ..", t, v1);
227	)
228	if (t) {
229	i = strtol(v1, &endptr, 0); /* Automatic base 10/16/8 switching */
230	if (v1 != '\0' && endptr == '\0') {
231	(int ) t = i;
232	DBG(printf(" Integer converted as %d, done\n", i);
233	)
234	} else {
235	/* XXX should tell line number to user */
236	fprintf(stderr, "Error: %s found where integer expected\n",
237	v1);
238	}
239	} else {
240	DBG(printf("skipped.\n");
241	)
242	}
243	}
244
245	static void c_set_unity(char v1, char v2, void *t)
246	{
247	DBG(printf("Setting pointer %p to unity\n", t);
248	)
249	if (t)
250	(int ) t = 1;
251	}
252
253	static void c_add_type(char v1, char v2, void *t)
254	{
255	add_mime_type(v1, v2);
256	}
257
258	static void c_add_alias(char v1, char v2, void *t)
259	{
260	add_alias(v2, v1, (int ) t);
261	}
262
263	struct ccommand lookup_keyword(char c)
264	{
265	struct ccommand *p;
266	DBG(printf("Checking string '%s' against keyword list\n", c);
267	)
268	for (p = clist;
269	p < clist + (sizeof (clist) / sizeof (struct ccommand)); p++) {
270	if (strcmp(c, p->name) == 0)
271	return p;
272	}
273	return NULL;
274	}
275
276	/*
277	* Name: read_config_files
278	*
279	* Description: Reads config files via yyparse, then makes sure that
280	* all required variables were set properly.
281	*/
282	void read_config_files(void)
283	{
284	char *temp;
285	current_uid = getuid();
286	yyin = fopen("boa.conf", "r");
287
288	if (!yyin) {
289	fputs("Could not open boa.conf for reading.\n", stderr);
290	exit(1);
291	}
292	if (yyparse()) {
293	fputs("Error parsing config files, exiting\n", stderr);
294	exit(1);
295	}
296
297	if (!server_name) {
298	struct hostent *he;
299	char temp_name[100];
300
301	if (gethostname(temp_name, 100) == -1) {
302	perror("gethostname:");
303	exit(1);
304	}
305
306	he = gethostbyname(temp_name);
307	if (he == NULL) {
308	perror("gethostbyname:");
309	exit(1);
310	}
311
312	server_name = strdup(he->h_name);
313	if (server_name == NULL) {
314	perror("strdup:");
315	exit(1);
316	}
317	}
318	tempdir = getenv("TMP");
319	if (tempdir == NULL)
320	tempdir = "/tmp";
321
322	if (single_post_limit < 0) {
323	fprintf(stderr, "Invalid value for single_post_limit: %d\n",
324	single_post_limit);
325	exit(1);
326	}
327
328	if (document_root) {
329	temp = normalize_path(document_root);
330	free(document_root);
331	document_root = temp;
332	}
333
334	if (error_log_name) {
335	temp = normalize_path(error_log_name);
336	free(error_log_name);
337	error_log_name = temp;
338	}
339
340	if (access_log_name) {
341	temp = normalize_path(access_log_name);
342	free(access_log_name);
343	access_log_name = temp;
344	}
345
346	if (cgi_log_name) {
347	temp = normalize_path(cgi_log_name);
348	free(cgi_log_name);
349	cgi_log_name = temp;
350	}
351
352	if (dirmaker) {
353	temp = normalize_path(dirmaker);
354	free(dirmaker);
355	dirmaker = temp;
356	}
357
358	#if 0
359	if (mime_types) {
360	temp = normalize_path(mime_types);
361	free(mime_types);
362	mime_types = temp;
363	}
364	#endif
365	}