hydra/src/boa.h

/*
 *  Boa, an http server
 *  Copyright (C) 1995 Paul Phillips <paulp@go2net.com>
 *  Some changes Copyright (C) 1996-99 Larry Doolittle <ldoolitt@jlab.org>
 *  Some changes Copyright (C) 1997-99 Jon Nelson <jnelson@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: boa.h,v 1.22 2002/09/29 11:00:04 nmav Exp $*/

#ifndef _BOA_H
#define _BOA_H

#include <errno.h>
#include <stdlib.h>             /* malloc, free, etc. */
#include <stdio.h>              /* stdin, stdout, stderr */
#include <string.h>             /* strdup */
#include <ctype.h>
#include <time.h>               /* localtime, time */
#include <pwd.h>
#include <grp.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>             /* OPEN_MAX */
#include <setjmp.h>

#include <netdb.h>
#include <netinet/in.h>

#include <sys/mman.h>
#include <sys/select.h>
#include <sys/types.h>          /* socket, bind, accept */
#include <sys/socket.h>         /* socket, bind, accept, setsockopt, */
#include <sys/stat.h>           /* open */

#include "compat.h"             /* oh what fun is porting */
#include "defines.h"
#include "hic.h"

#ifdef ENABLE_SMP
# include <pthread.h>
#endif

#ifdef HAVE_NETINET_TCP_H
# include <netinet/tcp.h>
#endif

#include "globals.h"

/* alias */
void add_alias(char* hostname, char *fakename, char *realname, int script);
int translate_uri(request * req);
int init_script_alias(request * req, alias * current, int uri_len);
void dump_alias( virthost*);

/* virthost */
void add_virthost(const char *host, const char *ip, const char* document_root, const char* user_dir);
virthost *find_virthost(const char *host, int hostlen);
void dump_virthost(void);

/* directory_index */
char *find_and_open_directory_index(const char *directory, int dirlen, int* fd);
void dump_directory_index(void);
void add_directory_index( const char* index);
char* find_default_directory_index( void);

/* config */
void read_config_files(void);

/* escape */
#include "escape.h"

/* get */

int init_get(server_params*, request * req);
int process_get(server_params*, request * req);
int get_dir(request * req, struct stat *statbuf);
const char* hydra_method_str( int method);

/* hash */
unsigned get_mime_hash_value(char *extension);
char *get_mime_type(const char *filename);
char *get_home_dir(char *name);
void dump_mime(void);
void dump_passwd(void);
void show_hash_stats(void);

int get_hash_value( const char* str);

#define get_alias_hash_value(x) (get_hash_value(x)%ALIAS_HASHTABLE_SIZE)
#define get_host_hash_value(x) (get_hash_value(x)%VIRTHOST_HASHTABLE_SIZE)
#define get_hic_module_hash_value(x) (get_hash_value(x)%MODULE_HASHTABLE_SIZE)

/* log */
void open_logs(void);
void close_access_log(void);
void log_access(request * req);
void log_error_doc(request * req);
void boa_perror(request * req, char *message);
void log_error_time(void);
void log_error_mesg(char *file, int line, char *mesg);

/* queue */
void block_request(server_params*, request * req);
void ready_request(server_params*, request * req);
void dequeue(request ** head, request * req);
void enqueue(request ** head, request * req);

/* read */
int read_header(server_params*, request * req);
int read_body(request * req);
int write_body(request * req);

/* request */
request *new_request(server_params* params);
void get_request(server_params* params, socket_type*);
void process_requests(server_params* params, socket_type* server_s);
int process_header_end(server_params*, request * req);
int process_header_line(request * req);
int process_logline(request * req);
int process_option_line(request * req);
void add_accept_header(request * req, char *mime_type);
void free_requests(server_params* params);

/* response */
void print_ka_phrase(request * req);
void print_content_type(request * req);
void print_content_length(request * req);
void print_last_modified(request * req);
void print_http_headers(request * req);

void send_r_request_ok(request * req); /* 200 */
void send_r_request_partial(request * req); /* 206 */
void send_r_moved_perm(request * req, char *url); /* 301 */
void send_r_moved_temp(request * req, char *url, char *more_hdr); /* 302 */
void send_r_not_modified(request * req); /* 304 */
void send_r_bad_request(request * req); /* 400 */
void send_r_unauthorized(request * req, char *name); /* 401 */
void send_r_forbidden(request * req); /* 403 */
void send_r_not_found(request * req); /* 404 */
void send_r_precondition_failed(request * req); /* 412 */
void send_r_range_unsatisfiable(request * req); /* 416 */
void send_r_error(request * req); /* 500 */
void send_r_not_implemented(request * req); /* 501 */
void send_r_bad_gateway(request * req); /* 502 */
void send_r_service_unavailable(request * req); /* 503 */
void send_r_bad_version(request * req); /* 505 */

/* cgi */
void create_common_env(void);
void clear_common_env(void);
int add_cgi_env(request * req, const char *key, const char *value, int http_prefix);
int complete_env(request * req);
void create_argv(request * req, char **aargv);
int init_cgi(request * req);
int is_executable_cgi( request* req, const char* filename);

/* signals */
void init_signals(void);
void block_main_signals(void);
void unblock_main_signals(void);
void block_sigusr2(void);
void unblock_sigusr2(void);
void sighup_run(void);
void sigchld_run(void);
void sigalrm_run(void);
void sigusr1_run(void);
void sigterm_stage1_run(void);
void sigterm_stage2_run(void);

/* smp */
void smp_reinit();
void hic_init();

/* util.c */
void clean_pathname(char *pathname);
void get_commonlog_time(char buf[30]);
void rfc822_time_buf(char *buf, time_t s);
int simple_itoa(unsigned long int i, char buf[22]);
int boa_atoi(const char *s);
long boa_atol(const char *s);
int create_etag(unsigned long int size, unsigned long int mod_time, 
   char buf[MAX_ETAG_LENGTH]);
char *escape_string(char *inp, char *buf);
int month2int(char *month);
int modified_since(time_t mtime, char *if_modified_since);
char *to_upper(char *str);
int unescape_uri(char *uri, char **query_string);
int create_temporary_file(short want_unlink, char *storage, int size);
char * normalize_path(char *path);
int real_set_block_fd(int fd);
int real_set_nonblock_fd(int fd);
void create_url( char * buffer, int buffer_size, int secure,
   const char* hostname, int port, const char* request_uri);
   
/* buffer */
int req_write(request * req, const char *msg);
void reset_output_buffer(request *req);
int req_write_escape_http(request * req, char *msg);
int req_write_escape_html(request * req, char *msg);
int req_flush(request * req);
char *escape_uri(char *uri);

/* timestamp */
void timestamp(void);

/* mmap_cache */
struct mmap_entry *find_mmap( int data_fd, struct stat *s);
void release_mmap( struct mmap_entry *e);
void initialize_mmap( void);
void mmap_reinit( void);

/* sublog */
int open_gen_fd(char *spec);
int process_cgi_header(request * req);

/* pipe */
int read_from_pipe(request * req);
int write_from_pipe(request * req);

/* ip */
int bind_server(int server_s, char *ip, int port);
char *ascii_sockaddr(struct SOCKADDR *s, char *dest, int len);
int net_port(struct SOCKADDR *s);

/* select */
void* select_loop(void*);

/* HIC stuff */
void* hic_main_loop(void*);

void dump_hic_modules( void);
void add_hic_module(const char *module, const char* sym_prefix, const char* file_suffix);
hic_module_st *find_hic_appr_module(const char *content_type, int content_type_len);

int hic_send_command( request *req, int out_fd);

#endif
1	nmav	1.1	/*
2			* Boa, an http server
3			* Copyright (C) 1995 Paul Phillips <paulp@go2net.com>
4			* Some changes Copyright (C) 1996-99 Larry Doolittle <ldoolitt@jlab.org>
5			* Some changes Copyright (C) 1997-99 Jon Nelson <jnelson@boa.org>
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 1, or (at your option)
10			* any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20			*
21			*/
22
23	nmav	1.23	/* $Id: boa.h,v 1.22 2002/09/29 11:00:04 nmav Exp $*/
24	nmav	1.1
25			#ifndef _BOA_H
26			#define _BOA_H
27
28			#include <errno.h>
29			#include <stdlib.h> /* malloc, free, etc. */
30			#include <stdio.h> /* stdin, stdout, stderr */
31			#include <string.h> /* strdup */
32			#include <ctype.h>
33			#include <time.h> /* localtime, time */
34			#include <pwd.h>
35			#include <grp.h>
36			#include <unistd.h>
37			#include <fcntl.h>
38			#include <limits.h> /* OPEN_MAX */
39			#include <setjmp.h>
40
41			#include <netdb.h>
42			#include <netinet/in.h>
43
44			#include <sys/mman.h>
45			#include <sys/select.h>
46			#include <sys/types.h> /* socket, bind, accept */
47			#include <sys/socket.h> /* socket, bind, accept, setsockopt, */
48			#include <sys/stat.h> /* open */
49
50			#include "compat.h" /* oh what fun is porting */
51			#include "defines.h"
52	nmav	1.14	#include "hic.h"
53	nmav	1.10
54			#ifdef ENABLE_SMP
55			# include <pthread.h>
56			#endif
57	nmav	1.4
58			#ifdef HAVE_NETINET_TCP_H
59			# include <netinet/tcp.h>
60			#endif
61
62	nmav	1.1	#include "globals.h"
63
64			/* alias */
65	nmav	1.7	void add_alias(char* hostname, char fakename, char realname, int script);
66	nmav	1.1	int translate_uri(request * req);
67			int init_script_alias(request * req, alias * current, int uri_len);
68	nmav	1.7	void dump_alias( virthost*);
69	nmav	1.5
70			/* virthost */
71			void add_virthost(const char host, const char ip, const char* document_root, const char* user_dir);
72			virthost find_virthost(const char host, int hostlen);
73	nmav	1.6	void dump_virthost(void);
74	nmav	1.9
75			/* directory_index */
76			char find_and_open_directory_index(const char directory, int dirlen, int* fd);
77			void dump_directory_index(void);
78			void add_directory_index( const char* index);
79			char* find_default_directory_index( void);
80	nmav	1.1
81			/* config */
82			void read_config_files(void);
83
84			/* escape */
85			#include "escape.h"
86
87			/* get */
88
89			int init_get(server_params, request req);
90			int process_get(server_params, request req);
91			int get_dir(request * req, struct stat *statbuf);
92	nmav	1.11	const char* hydra_method_str( int method);
93	nmav	1.1
94			/* hash */
95			unsigned get_mime_hash_value(char *extension);
96	nmav	1.19	char get_mime_type(const char filename);
97	nmav	1.1	char get_home_dir(char name);
98			void dump_mime(void);
99			void dump_passwd(void);
100			void show_hash_stats(void);
101
102	nmav	1.15	int get_hash_value( const char* str);
103
104			#define get_alias_hash_value(x) (get_hash_value(x)%ALIAS_HASHTABLE_SIZE)
105			#define get_host_hash_value(x) (get_hash_value(x)%VIRTHOST_HASHTABLE_SIZE)
106	nmav	1.16	#define get_hic_module_hash_value(x) (get_hash_value(x)%MODULE_HASHTABLE_SIZE)
107	nmav	1.15
108	nmav	1.1	/* log */
109			void open_logs(void);
110			void close_access_log(void);
111			void log_access(request * req);
112			void log_error_doc(request * req);
113			void boa_perror(request * req, char *message);
114			void log_error_time(void);
115			void log_error_mesg(char file, int line, char mesg);
116
117			/* queue */
118			void block_request(server_params, request req);
119			void ready_request(server_params, request req);
120			void dequeue(request ** head, request * req);
121			void enqueue(request ** head, request * req);
122
123			/* read */
124			int read_header(server_params, request req);
125			int read_body(request * req);
126			int write_body(request * req);
127
128			/* request */
129			request new_request(server_params params);
130	nmav	1.4	void get_request(server_params* params, socket_type*);
131			void process_requests(server_params* params, socket_type* server_s);
132	nmav	1.1	int process_header_end(server_params, request req);
133			int process_header_line(request * req);
134			int process_logline(request * req);
135			int process_option_line(request * req);
136			void add_accept_header(request * req, char *mime_type);
137			void free_requests(server_params* params);
138
139			/* response */
140			void print_ka_phrase(request * req);
141			void print_content_type(request * req);
142			void print_content_length(request * req);
143			void print_last_modified(request * req);
144			void print_http_headers(request * req);
145
146			void send_r_request_ok(request * req); /* 200 */
147	nmav	1.3	void send_r_request_partial(request * req); /* 206 */
148	nmav	1.1	void send_r_moved_perm(request * req, char url); / 301 */
149			void send_r_moved_temp(request * req, char url, char more_hdr); /* 302 */
150			void send_r_not_modified(request * req); /* 304 */
151			void send_r_bad_request(request * req); /* 400 */
152			void send_r_unauthorized(request * req, char name); / 401 */
153			void send_r_forbidden(request * req); /* 403 */
154			void send_r_not_found(request * req); /* 404 */
155	nmav	1.22	void send_r_precondition_failed(request * req); /* 412 */
156	nmav	1.3	void send_r_range_unsatisfiable(request * req); /* 416 */
157	nmav	1.1	void send_r_error(request * req); /* 500 */
158			void send_r_not_implemented(request * req); /* 501 */
159			void send_r_bad_gateway(request * req); /* 502 */
160			void send_r_service_unavailable(request * req); /* 503 */
161			void send_r_bad_version(request * req); /* 505 */
162
163			/* cgi */
164			void create_common_env(void);
165			void clear_common_env(void);
166	nmav	1.12	int add_cgi_env(request * req, const char key, const char value, int http_prefix);
167	nmav	1.1	int complete_env(request * req);
168			void create_argv(request * req, char **aargv);
169			int init_cgi(request * req);
170	nmav	1.19	int is_executable_cgi( request* req, const char* filename);
171	nmav	1.1
172			/* signals */
173			void init_signals(void);
174			void block_main_signals(void);
175			void unblock_main_signals(void);
176	nmav	1.18	void block_sigusr2(void);
177			void unblock_sigusr2(void);
178	nmav	1.1	void sighup_run(void);
179			void sigchld_run(void);
180			void sigalrm_run(void);
181			void sigusr1_run(void);
182			void sigterm_stage1_run(void);
183			void sigterm_stage2_run(void);
184
185			/* smp */
186			void smp_reinit();
187	nmav	1.20	void hic_init();
188	nmav	1.1
189			/* util.c */
190			void clean_pathname(char *pathname);
191	nmav	1.2	void get_commonlog_time(char buf[30]);
192	nmav	1.1	void rfc822_time_buf(char *buf, time_t s);
193	nmav	1.23	int simple_itoa(unsigned long int i, char buf[22]);
194	nmav	1.3	int boa_atoi(const char *s);
195	nmav	1.17	long boa_atol(const char *s);
196	nmav	1.23	int create_etag(unsigned long int size, unsigned long int mod_time,
197			char buf[MAX_ETAG_LENGTH]);
198	nmav	1.1	char escape_string(char inp, char *buf);
199			int month2int(char *month);
200	nmav	1.22	int modified_since(time_t mtime, char *if_modified_since);
201	nmav	1.1	char to_upper(char str);
202			int unescape_uri(char uri, char *query_string);
203			int create_temporary_file(short want_unlink, char *storage, int size);
204			char * normalize_path(char *path);
205			int real_set_block_fd(int fd);
206			int real_set_nonblock_fd(int fd);
207	nmav	1.21	void create_url( char * buffer, int buffer_size, int secure,
208			const char* hostname, int port, const char* request_uri);
209
210	nmav	1.1	/* buffer */
211	nmav	1.2	int req_write(request * req, const char *msg);
212	nmav	1.1	void reset_output_buffer(request *req);
213			int req_write_escape_http(request * req, char *msg);
214			int req_write_escape_html(request * req, char *msg);
215			int req_flush(request * req);
216			char escape_uri(char uri);
217
218			/* timestamp */
219			void timestamp(void);
220
221			/* mmap_cache */
222			struct mmap_entry find_mmap( int data_fd, struct stat s);
223			void release_mmap( struct mmap_entry *e);
224	nmav	1.8	void initialize_mmap( void);
225			void mmap_reinit( void);
226	nmav	1.1
227			/* sublog */
228			int open_gen_fd(char *spec);
229			int process_cgi_header(request * req);
230
231			/* pipe */
232			int read_from_pipe(request * req);
233			int write_from_pipe(request * req);
234
235			/* ip */
236			int bind_server(int server_s, char *ip, int port);
237			char ascii_sockaddr(struct SOCKADDR s, char *dest, int len);
238			int net_port(struct SOCKADDR *s);
239
240			/* select */
241			void* select_loop(void*);
242	nmav	1.14
243			/* HIC stuff */
244	nmav	1.13	void* hic_main_loop(void*);
245
246	nmav	1.15	void dump_hic_modules( void);
247	nmav	1.14	void add_hic_module(const char module, const char sym_prefix, const char* file_suffix);
248	nmav	1.15	hic_module_st find_hic_appr_module(const char content_type, int content_type_len);
249
250	nmav	1.13	int hic_send_command( request *req, int out_fd);
251	nmav	1.1
252			#endif