hydra/src/config.c

/*
 *  Hydra, 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.12 2002/09/30 17:16:54 nmav Exp $*/

#include "boa.h"
#include "boa_grammar.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;
long int max_connections;

int max_files_cache = 256;
int max_file_size_cache = 100 * 1024;

int max_server_threads = 1;
int max_hic_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 *default_document_root;
int default_document_root_size;

char *default_type;
char *dirmaker;
char *cachedir;

char *tempdir;
int tempdir_len = 0;

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, char* v3, char* v4, void *t);
static void c_set_group(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_set_string(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_set_int(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_set_longint(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_set_unity(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_add_type(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_add_vhost(char *v1, char* v2, char* v3, char*v4, void *t);
static void c_add_alias(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_add_dirindex(char *v1, char* v2, char* v3, char* v4, void *t);
static void c_add_hic_module(char *v1, char* v2, char* v3, char* v4, 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
#define S3A STMT_THREE_ARGS
#define S4A STMT_FOUR_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, &max_server_threads},
    {"HICThreads", S1A, c_set_int, &max_hic_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},
    {"DocumentRoot", S1A, c_set_string, &default_document_root},
    {"DirectoryIndex", S1A, c_add_dirindex, NULL},
    {"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},
    {"HICModule", S3A, c_add_hic_module, NULL},
    {"ScriptAlias", S3A, c_add_alias, &script_number},
    {"Redirect", S3A, c_add_alias, &redirect_number},
    {"Alias", S3A, c_add_alias, &alias_number},
/* HOST - IP - DOCUMENT_ROOT - USER_DIR */
    {"VirtualHost", S4A, c_add_vhost, NULL},
    {"SinglePostLimit", S1A, c_set_int, &single_post_limit},
    {"CGIPath", S1A, c_set_string, &cgi_path},
    {"MaxConnections", S1A, c_set_longint, &max_connections},
    {"MaxFilesCache", S1A, c_set_int, &max_files_cache},
    {"MaxFileSizeCache", S1A, c_set_int, &max_file_size_cache},
};

static void c_set_user(char *v1, char* v2, char* v3, char* v4, 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, char* v3, char* v4, 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, char* v3, char* v4, 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, char* v3, char* v4, 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_longint(char *v1, char* v2, char* v3, char* v4, void *t)
{
    char *endptr;
    int i;
    DBG(printf("Setting pointer %p to long integer string %s ..", t, v1);
        )
        if (t) {
        i = strtol(v1, &endptr, 0); /* Automatic base 10/16/8 switching */
        if (*v1 != '\0' && *endptr == '\0') {
            *(long 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, char* v3, char* v4, 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, char* v3, char* v4, void *t)
{
    add_mime_type(v1, v2);
}

static void c_add_hic_module(char *v1, char* v2, char* v3, char* v4, void *t)
{
    add_hic_module(v1, v2, v3);
}

static void c_add_dirindex(char *v1, char* v2, char* v3, char* v4, void *t)
{
    add_directory_index(v1);
}

static void c_add_vhost(char *v1, char *v2, char* v3, char* v4, void *t)
{
    add_virthost(v1, v2, v3, v4);
}


static void c_add_alias(char *v1, char *v2, char* v3, char* v4, void *t)
{
    add_alias(v1, v3, v2, *(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("hydra.conf", "r");

    if (!yyin) {
        fputs("Could not open hydra.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";
    tempdir_len = strlen( tempdir);

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

    if (default_document_root) {
        temp = normalize_path(default_document_root);
        free(default_document_root);
        default_document_root = temp;
        default_document_root_size = strlen( default_document_root);
        if ( default_document_root_size > MAX_PATH_LENGTH) {
           log_error_time();
           fprintf(stderr, "DocumentRoot size is too long\n");
           exit(1);
        }
    } else default_document_root_size = 0;

    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	nmav	1.1	/*
2	nmav	1.10	* Hydra, an http server
3	nmav	1.1	* 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	nmav	1.13	/* $Id: config.c,v 1.12 2002/09/30 17:16:54 nmav Exp $*/
22	nmav	1.1
23			#include "boa.h"
24	nmav	1.8	#include "boa_grammar.h"
25	nmav	1.1	#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			long int max_connections;
43
44	nmav	1.6	int max_files_cache = 256;
45			int max_file_size_cache = 100 * 1024;
46
47	nmav	1.12	int max_server_threads = 1;
48			int max_hic_threads = 1;
49	nmav	1.1
50			char *server_cert;
51			char *server_key;
52			int ssl_session_cache;
53			int boa_ssl = 0;
54			int ssl_port = 443;
55			int ssl_dh_bits = 1024; /* default value */
56			int ssl_session_timeout = 3600;
57			int ssl_params_refresh = 432000; /* every 5 days */
58
59			char *ssl_ciphers = NULL;
60			char *ssl_mac = NULL;
61			char *ssl_kx = NULL;
62			char *ssl_comp = NULL;
63			char *ssl_protocol = NULL;
64
65	nmav	1.2	char *default_document_root;
66	nmav	1.3	int default_document_root_size;
67
68	nmav	1.1	char *default_type;
69			char *dirmaker;
70			char *cachedir;
71
72			char *tempdir;
73	nmav	1.11	int tempdir_len = 0;
74	nmav	1.1
75			char *cgi_path = NULL;
76			int single_post_limit = SINGLE_POST_LIMIT_DEFAULT;
77
78			int ka_timeout;
79			int ka_max;
80
81			/* These came from log.c */
82			char *error_log_name;
83			char *access_log_name;
84			char *cgi_log_name;
85
86			int use_localtime;
87
88			/* These are new */
89	nmav	1.2	static void c_set_user(char v1, char v2, char* v3, char* v4, void *t);
90			static void c_set_group(char v1, char v2, char* v3, char* v4, void *t);
91			static void c_set_string(char v1, char v2, char* v3, char* v4, void *t);
92			static void c_set_int(char v1, char v2, char* v3, char* v4, void *t);
93	nmav	1.13	static void c_set_longint(char v1, char v2, char* v3, char* v4, void *t);
94	nmav	1.2	static void c_set_unity(char v1, char v2, char* v3, char* v4, void *t);
95			static void c_add_type(char v1, char v2, char* v3, char* v4, void *t);
96			static void c_add_vhost(char v1, char v2, char* v3, charv4, void t);
97			static void c_add_alias(char v1, char v2, char* v3, char* v4, void *t);
98	nmav	1.7	static void c_add_dirindex(char v1, char v2, char* v3, char* v4, void *t);
99	nmav	1.9	static void c_add_hic_module(char v1, char v2, char* v3, char* v4, void *t);
100	nmav	1.1
101			/* Fakery to keep the value passed to action() a void *,
102			see usage in table and c_add_alias() below */
103			static int script_number = SCRIPTALIAS;
104			static int redirect_number = REDIRECT;
105			static int alias_number = ALIAS;
106			static uid_t current_uid=0;
107
108			/* Help keep the table below compact */
109			#define S0A STMT_NO_ARGS
110			#define S1A STMT_ONE_ARG
111			#define S2A STMT_TWO_ARGS
112	nmav	1.4	#define S3A STMT_THREE_ARGS
113	nmav	1.2	#define S4A STMT_FOUR_ARGS
114	nmav	1.1
115			struct ccommand clist[] = {
116			{"SSLCiphers", S1A, c_set_string, &ssl_ciphers},
117			{"SSLKeyExchangeAlgorithms", S1A, c_set_string, &ssl_kx},
118			{"SSLMACAlgorithms", S1A, c_set_string, &ssl_mac},
119			{"SSLProtocols", S1A, c_set_string, &ssl_protocol},
120			{"SSLCompressionMethods", S1A, c_set_string, &ssl_comp},
121			{"SSLCertificate", S1A, c_set_string, &server_cert},
122			{"SSLKey", S1A, c_set_string, &server_key},
123			{"SSLSessionCache", S1A, c_set_int, &ssl_session_cache},
124			{"SSL", S1A, c_set_int, &boa_ssl},
125			{"SSLPort", S1A, c_set_int, &ssl_port},
126			{"SSLDHBits", S1A, c_set_int, &ssl_dh_bits},
127			{"SSLSessionTimeout", S1A, c_set_int, &ssl_session_timeout},
128			{"SSLParamsRefresh", S1A, c_set_int, &ssl_params_refresh},
129	nmav	1.12	{"Threads", S1A, c_set_int, &max_server_threads},
130			{"HICThreads", S1A, c_set_int, &max_hic_threads},
131	nmav	1.1	{"Port", S1A, c_set_int, &server_port},
132			{"Listen", S1A, c_set_string, &server_ip},
133			{"BackLog", S1A, c_set_int, &backlog},
134			{"User", S1A, c_set_user, NULL},
135			{"Group", S1A, c_set_group, NULL},
136			{"ServerAdmin", S1A, c_set_string, &server_admin},
137			{"ServerRoot", S1A, c_set_string, &server_root},
138			{"ErrorLog", S1A, c_set_string, &error_log_name},
139			{"AccessLog", S1A, c_set_string, &access_log_name},
140			{"UseLocaltime", S0A, c_set_unity, &use_localtime},
141			{"CgiLog", S1A, c_set_string, &cgi_log_name},
142			{"VerboseCGILogs", S0A, c_set_unity, &verbose_cgi_logs},
143			{"ServerName", S1A, c_set_string, &server_name},
144	nmav	1.2	{"DocumentRoot", S1A, c_set_string, &default_document_root},
145	nmav	1.7	{"DirectoryIndex", S1A, c_add_dirindex, NULL},
146	nmav	1.1	{"DirectoryMaker", S1A, c_set_string, &dirmaker},
147			{"DirectoryCache", S1A, c_set_string, &cachedir},
148			{"KeepAliveMax", S1A, c_set_int, &ka_max},
149			{"KeepAliveTimeout", S1A, c_set_int, &ka_timeout},
150			{"MimeTypes", S1A, c_set_string, &mime_types},
151			{"DefaultType", S1A, c_set_string, &default_type},
152			{"AddType", S2A, c_add_type, NULL},
153	nmav	1.9	{"HICModule", S3A, c_add_hic_module, NULL},
154	nmav	1.4	{"ScriptAlias", S3A, c_add_alias, &script_number},
155			{"Redirect", S3A, c_add_alias, &redirect_number},
156			{"Alias", S3A, c_add_alias, &alias_number},
157	nmav	1.2	/* HOST - IP - DOCUMENT_ROOT - USER_DIR */
158			{"VirtualHost", S4A, c_add_vhost, NULL},
159	nmav	1.1	{"SinglePostLimit", S1A, c_set_int, &single_post_limit},
160			{"CGIPath", S1A, c_set_string, &cgi_path},
161	nmav	1.13	{"MaxConnections", S1A, c_set_longint, &max_connections},
162	nmav	1.6	{"MaxFilesCache", S1A, c_set_int, &max_files_cache},
163			{"MaxFileSizeCache", S1A, c_set_int, &max_file_size_cache},
164	nmav	1.1	};
165
166	nmav	1.2	static void c_set_user(char v1, char v2, char* v3, char* v4, void *t)
167	nmav	1.1	{
168			struct passwd *passwdbuf;
169			char *endptr;
170			int i;
171
172			DBG(printf("User %s = ", v1);
173			)
174			i = strtol(v1, &endptr, 0);
175			if (v1 != '\0' && endptr == '\0') {
176			server_uid = i;
177			} else {
178			passwdbuf = getpwnam(v1);
179			if (!passwdbuf) {
180			if (current_uid)
181			return;
182			fprintf(stderr, "No such user: %s\n", v1);
183			exit(1);
184			}
185			server_uid = passwdbuf->pw_uid;
186			}
187			DBG(printf("%d\n", server_uid);
188			)
189			}
190
191	nmav	1.2	static void c_set_group(char v1, char v2, char* v3, char* v4, void *t)
192	nmav	1.1	{
193			struct group *groupbuf;
194			char *endptr;
195			int i;
196			DBG(printf("Group %s = ", v1);
197			)
198			i = strtol(v1, &endptr, 0);
199			if (v1 != '\0' && endptr == '\0') {
200			server_gid = i;
201			} else {
202			groupbuf = getgrnam(v1);
203			if (!groupbuf) {
204			if (current_uid)
205			return;
206			fprintf(stderr, "No such group: %s\n", v1);
207			exit(1);
208			}
209			server_gid = groupbuf->gr_gid;
210			}
211			DBG(printf("%d\n", server_gid);
212			)
213			}
214
215	nmav	1.2	static void c_set_string(char v1, char v2, char* v3, char* v4, void *t)
216	nmav	1.1	{
217			char *s;
218			DBG(printf("Setting pointer %p to string %s ..", t, v1);
219			)
220			if (t) {
221			s = (char *) t;
222			if (s)
223			free(s);
224			(char *) t = strdup(v1);
225			if (!(char *) t) {
226			DIE("Unable to strdup in c_set_string");
227			}
228			DBG(printf("done.\n");
229			)
230			} else {
231			DBG(printf("skipped.\n");
232			)
233			}
234			}
235
236	nmav	1.2	static void c_set_int(char v1, char v2, char* v3, char* v4, void *t)
237	nmav	1.1	{
238			char *endptr;
239			int i;
240			DBG(printf("Setting pointer %p to integer string %s ..", t, v1);
241			)
242			if (t) {
243			i = strtol(v1, &endptr, 0); /* Automatic base 10/16/8 switching */
244			if (v1 != '\0' && endptr == '\0') {
245			(int ) t = i;
246	nmav	1.13	DBG(printf(" Integer converted as %d, done\n", i);
247			)
248			} else {
249			/* XXX should tell line number to user */
250			fprintf(stderr, "Error: %s found where integer expected\n",
251			v1);
252			}
253			} else {
254			DBG(printf("skipped.\n");
255			)
256			}
257			}
258
259			static void c_set_longint(char v1, char v2, char* v3, char* v4, void *t)
260			{
261			char *endptr;
262			int i;
263			DBG(printf("Setting pointer %p to long integer string %s ..", t, v1);
264			)
265			if (t) {
266			i = strtol(v1, &endptr, 0); /* Automatic base 10/16/8 switching */
267			if (v1 != '\0' && endptr == '\0') {
268			(long int ) t = i;
269	nmav	1.1	DBG(printf(" Integer converted as %d, done\n", i);
270			)
271			} else {
272			/* XXX should tell line number to user */
273			fprintf(stderr, "Error: %s found where integer expected\n",
274			v1);
275			}
276			} else {
277			DBG(printf("skipped.\n");
278			)
279			}
280			}
281
282	nmav	1.2	static void c_set_unity(char v1, char v2, char* v3, char* v4, void *t)
283	nmav	1.1	{
284			DBG(printf("Setting pointer %p to unity\n", t);
285			)
286			if (t)
287			(int ) t = 1;
288			}
289
290	nmav	1.2	static void c_add_type(char v1, char v2, char* v3, char* v4, void *t)
291	nmav	1.1	{
292			add_mime_type(v1, v2);
293	nmav	1.9	}
294
295			static void c_add_hic_module(char v1, char v2, char* v3, char* v4, void *t)
296			{
297			add_hic_module(v1, v2, v3);
298	nmav	1.7	}
299
300			static void c_add_dirindex(char v1, char v2, char* v3, char* v4, void *t)
301			{
302			add_directory_index(v1);
303	nmav	1.1	}
304
305	nmav	1.2	static void c_add_vhost(char v1, char v2, char* v3, char* v4, void *t)
306			{
307			add_virthost(v1, v2, v3, v4);
308			}
309
310
311			static void c_add_alias(char v1, char v2, char* v3, char* v4, void *t)
312	nmav	1.1	{
313	nmav	1.4	add_alias(v1, v3, v2, (int ) t);
314	nmav	1.1	}
315
316			struct ccommand lookup_keyword(char c)
317			{
318			struct ccommand *p;
319			DBG(printf("Checking string '%s' against keyword list\n", c);
320			)
321			for (p = clist;
322			p < clist + (sizeof (clist) / sizeof (struct ccommand)); p++) {
323			if (strcmp(c, p->name) == 0)
324			return p;
325			}
326			return NULL;
327			}
328
329			/*
330			* Name: read_config_files
331			*
332			* Description: Reads config files via yyparse, then makes sure that
333			* all required variables were set properly.
334			*/
335			void read_config_files(void)
336			{
337			char *temp;
338			current_uid = getuid();
339	nmav	1.5	yyin = fopen("hydra.conf", "r");
340	nmav	1.1
341			if (!yyin) {
342	nmav	1.5	fputs("Could not open hydra.conf for reading.\n", stderr);
343	nmav	1.1	exit(1);
344			}
345			if (yyparse()) {
346			fputs("Error parsing config files, exiting\n", stderr);
347			exit(1);
348			}
349
350			if (!server_name) {
351			struct hostent *he;
352			char temp_name[100];
353
354			if (gethostname(temp_name, 100) == -1) {
355			perror("gethostname:");
356			exit(1);
357			}
358
359			he = gethostbyname(temp_name);
360			if (he == NULL) {
361			perror("gethostbyname:");
362			exit(1);
363			}
364
365			server_name = strdup(he->h_name);
366			if (server_name == NULL) {
367			perror("strdup:");
368			exit(1);
369			}
370			}
371			tempdir = getenv("TMP");
372			if (tempdir == NULL)
373			tempdir = "/tmp";
374	nmav	1.11	tempdir_len = strlen( tempdir);
375	nmav	1.1
376			if (single_post_limit < 0) {
377			fprintf(stderr, "Invalid value for single_post_limit: %d\n",
378			single_post_limit);
379			exit(1);
380			}
381
382	nmav	1.2	if (default_document_root) {
383			temp = normalize_path(default_document_root);
384			free(default_document_root);
385			default_document_root = temp;
386	nmav	1.3	default_document_root_size = strlen( default_document_root);
387			if ( default_document_root_size > MAX_PATH_LENGTH) {
388			log_error_time();
389			fprintf(stderr, "DocumentRoot size is too long\n");
390			exit(1);
391			}
392			} else default_document_root_size = 0;
393	nmav	1.1
394			if (error_log_name) {
395			temp = normalize_path(error_log_name);
396			free(error_log_name);
397			error_log_name = temp;
398			}
399
400			if (access_log_name) {
401			temp = normalize_path(access_log_name);
402			free(access_log_name);
403			access_log_name = temp;
404			}
405
406			if (cgi_log_name) {
407			temp = normalize_path(cgi_log_name);
408			free(cgi_log_name);
409			cgi_log_name = temp;
410			}
411
412			if (dirmaker) {
413			temp = normalize_path(dirmaker);
414			free(dirmaker);
415			dirmaker = temp;
416			}
417
418			#if 0
419			if (mime_types) {
420			temp = normalize_path(mime_types);
421			free(mime_types);
422			mime_types = temp;
423			}
424			#endif
425			}