hydra/src/hic_modules.c

/*
 *  Hydra, an http server
 *  Copyright (C) 2002 Nikos Mavroyanopoulos <nmav@gnutls.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: hic_modules.c,v 1.4 2002/09/28 16:32:37 nmav Exp $ */

/* This file includes support for dynamically loaded HIC modules
 * All modules added to module_table[] will be dlopen()ed at startup.
 *
 * Also hic symbols will be resolved.
 */

#include "boa.h"

#ifdef ENABLE_HIC
# include <dlfcn.h>
#endif

/* A dynamic module, must provide three functions:
 * void     _php_hic_shutdown(void);
 * void     _php_hic_init(void);
 * off_t    _php_hic_request(hic_stuff *hc);
 *
 * This is from php.
 */


static hic_module_st* module_hashtable[MODULE_HASHTABLE_SIZE];

/*
 * Name: add_module
 *
 * Description: add an module entry
 */

void add_hic_module(const char *module, const char* sym_prefix, const char* content_type)
{
#ifndef ENABLE_HIC
    log_error_time();
    fprintf(stderr, "Cannot open '%s' since dynamic module opening, is not supported in this system.\n", module);
#else
char symbol[128];
int hash;
hic_module_st* old, *start;

    int sym_prefix_len;
    void * handle;

    /* sanity checking */
    if (module == NULL || sym_prefix == NULL || content_type == NULL) {
        DIE("NULL values sent to add_module");
    }

    hash = get_hic_module_hash_value( content_type);
    start = old = module_hashtable[hash];
    
    if ( old != NULL) {
       /* find next empty */
       do {
          hash = (hash + 1) % MODULE_HASHTABLE_SIZE;
          
          old = module_hashtable[hash];

          if (start == old) {
             DIE("Module hashtable is full.");
          }
          
       } while( old != NULL);
    }
    
    /* old was found, and is empty. */
    
    old = malloc( sizeof(hic_module_st));
    if (old==NULL) {
       DIE("malloc() failed.");
    }

    old->sym_prefix = strdup( sym_prefix);
    if (old->sym_prefix == NULL) {
       DIE("strdup() failed.");
    }

    old->content_type = strdup( content_type);
    if (old->content_type == NULL) {
       DIE("strdup() failed.");
    }

    old->content_type_len = strlen( content_type);


    handle = dlopen( module, RTLD_NOW);
    if ( handle==NULL) {
       fprintf(stderr, "Could not load module '%s'. Dlopen failed.\n", module);
       exit(1);
    }
    old->dl_handle = handle;


    sym_prefix_len = strlen( sym_prefix);
    if (sym_prefix_len + 20 > sizeof(symbol)) {
        DIE("Symbol prefix is too long.");
    }

    /* Resolve shutdown */
    strcpy( symbol, sym_prefix);
    strcat( symbol, "_hic_shutdown");
   
    old->shutdown = dlsym( handle, symbol);
    if ( old->shutdown == NULL) {
       fprintf(stderr, "Could not resolve %s_hic_shutdown symbol", sym_prefix);
       exit(1);
    }

    /* Resolve init */
    strcpy( symbol, sym_prefix);
    strcat( symbol, "_hic_init");

    old->init = dlsym( handle, symbol);
    if ( old->init == NULL) {
       fprintf(stderr, "Could not resolve %s_hic_init symbol", sym_prefix);
       exit(1);
    }
    old->init(); /* Run the initialization stuff */

    /* Resolve request */
    strcpy( symbol, sym_prefix);
    strcat( symbol, "_hic_request");

    old->request = dlsym( handle, symbol);
    if ( old->request == NULL) {
       fprintf(stderr, "Could not resolve %s_hic_request symbol", sym_prefix);
       exit(1);
    }

    module_hashtable[hash] = old;

    return;
#endif
}

/*
 * Name: find_hic_appr_module
 *
 * Description: Locates the appropriate HIC module for the given file.
 * Actually ones needs this to get the dlsymed() functions.
 * 
 * Returns:
 *
 * a pointer to a hic_module_st structure or NULL if not found
 */

hic_module_st *find_hic_appr_module(const char *content_type, int content_type_len)
{
int i, hash;

   if (content_type == NULL) return NULL;
   if (content_type_len == 0) content_type_len = strlen( content_type);

   hash = get_hic_module_hash_value( content_type);
   for (i=hash;i<MODULE_HASHTABLE_SIZE;i++) {
      if (module_hashtable[i] == NULL) break;

      if ( content_type_len != module_hashtable[i]->content_type_len) continue;

      if (memcmp( content_type, module_hashtable[i]->content_type, 
        content_type_len) == 0) {
        /* FOUND! */
        return module_hashtable[i];
      }
   }
 
   return NULL;

}


/*
 * Empties the hic modules table, deallocating any allocated memory.
 */

void dump_hic_modules(void)
{
#ifdef ENABLE_HIC
int i;

    for (i = 0; i < MODULE_HASHTABLE_SIZE; ++i) { /* these limits OK? */
        if (!module_hashtable[i]) continue;

        free( module_hashtable[i]->sym_prefix);
        free( module_hashtable[i]->content_type);
        module_hashtable[i]->shutdown(); /* Run the deinitialization stuff */
        dlclose( module_hashtable[i]->dl_handle);
        free( module_hashtable[i]);
        module_hashtable[i] = NULL;
    }
#endif
}
1	nmav	1.1	/*
2	nmav	1.4	* Hydra, an http server
3	nmav	1.1	* Copyright (C) 2002 Nikos Mavroyanopoulos <nmav@gnutls.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.5	/* $Id: hic_modules.c,v 1.4 2002/09/28 16:32:37 nmav Exp $ */
22	nmav	1.1
23			/* This file includes support for dynamically loaded HIC modules
24			* All modules added to module_table[] will be dlopen()ed at startup.
25			*
26			* Also hic symbols will be resolved.
27			*/
28
29			#include "boa.h"
30
31			#ifdef ENABLE_HIC
32			# include <dlfcn.h>
33			#endif
34
35			/* A dynamic module, must provide three functions:
36			* void _php_hic_shutdown(void);
37			* void _php_hic_init(void);
38			* off_t _php_hic_request(hic_stuff *hc);
39			*
40			* This is from php.
41			*/
42
43
44	nmav	1.3	static hic_module_st* module_hashtable[MODULE_HASHTABLE_SIZE];
45	nmav	1.1
46			/*
47			* Name: add_module
48			*
49			* Description: add an module entry
50			*/
51
52	nmav	1.2	void add_hic_module(const char module, const char sym_prefix, const char* content_type)
53	nmav	1.1	{
54			#ifndef ENABLE_HIC
55			log_error_time();
56			fprintf(stderr, "Cannot open '%s' since dynamic module opening, is not supported in this system.\n", module);
57			#else
58			char symbol[128];
59	nmav	1.2	int hash;
60			hic_module_st* old, *start;
61	nmav	1.1
62			int sym_prefix_len;
63			void * handle;
64
65			/* sanity checking */
66	nmav	1.2	if (module == NULL \|\| sym_prefix == NULL \|\| content_type == NULL) {
67	nmav	1.1	DIE("NULL values sent to add_module");
68			}
69
70	nmav	1.2	hash = get_hic_module_hash_value( content_type);
71			start = old = module_hashtable[hash];
72
73			if ( old != NULL) {
74			/* find next empty */
75			do {
76	nmav	1.3	hash = (hash + 1) % MODULE_HASHTABLE_SIZE;
77	nmav	1.2
78			old = module_hashtable[hash];
79
80			if (start == old) {
81			DIE("Module hashtable is full.");
82			}
83
84			} while( old != NULL);
85			}
86
87			/* old was found, and is empty. */
88
89			old = malloc( sizeof(hic_module_st));
90			if (old==NULL) {
91			DIE("malloc() failed.");
92	nmav	1.1	}
93
94	nmav	1.2	old->sym_prefix = strdup( sym_prefix);
95			if (old->sym_prefix == NULL) {
96			DIE("strdup() failed.");
97	nmav	1.1	}
98
99	nmav	1.2	old->content_type = strdup( content_type);
100			if (old->content_type == NULL) {
101	nmav	1.1	DIE("strdup() failed.");
102			}
103
104	nmav	1.2	old->content_type_len = strlen( content_type);
105
106
107			handle = dlopen( module, RTLD_NOW);
108			if ( handle==NULL) {
109			fprintf(stderr, "Could not load module '%s'. Dlopen failed.\n", module);
110			exit(1);
111	nmav	1.1	}
112	nmav	1.2	old->dl_handle = handle;
113	nmav	1.1
114
115			sym_prefix_len = strlen( sym_prefix);
116			if (sym_prefix_len + 20 > sizeof(symbol)) {
117			DIE("Symbol prefix is too long.");
118			}
119
120			/* Resolve shutdown */
121			strcpy( symbol, sym_prefix);
122			strcat( symbol, "_hic_shutdown");
123
124	nmav	1.2	old->shutdown = dlsym( handle, symbol);
125			if ( old->shutdown == NULL) {
126	nmav	1.1	fprintf(stderr, "Could not resolve %s_hic_shutdown symbol", sym_prefix);
127			exit(1);
128			}
129
130			/* Resolve init */
131			strcpy( symbol, sym_prefix);
132			strcat( symbol, "_hic_init");
133
134	nmav	1.2	old->init = dlsym( handle, symbol);
135			if ( old->init == NULL) {
136	nmav	1.1	fprintf(stderr, "Could not resolve %s_hic_init symbol", sym_prefix);
137			exit(1);
138			}
139	nmav	1.2	old->init(); /* Run the initialization stuff */
140	nmav	1.1
141			/* Resolve request */
142			strcpy( symbol, sym_prefix);
143			strcat( symbol, "_hic_request");
144
145	nmav	1.2	old->request = dlsym( handle, symbol);
146			if ( old->request == NULL) {
147	nmav	1.1	fprintf(stderr, "Could not resolve %s_hic_request symbol", sym_prefix);
148			exit(1);
149			}
150
151	nmav	1.2	module_hashtable[hash] = old;
152
153	nmav	1.1	return;
154			#endif
155			}
156
157			/*
158	nmav	1.2	* Name: find_hic_appr_module
159	nmav	1.1	*
160			* Description: Locates the appropriate HIC module for the given file.
161			* Actually ones needs this to get the dlsymed() functions.
162			*
163			* Returns:
164			*
165			* a pointer to a hic_module_st structure or NULL if not found
166			*/
167
168	nmav	1.2	hic_module_st find_hic_appr_module(const char content_type, int content_type_len)
169	nmav	1.1	{
170	nmav	1.2	int i, hash;
171	nmav	1.1
172	nmav	1.2	if (content_type == NULL) return NULL;
173			if (content_type_len == 0) content_type_len = strlen( content_type);
174	nmav	1.1
175	nmav	1.2	hash = get_hic_module_hash_value( content_type);
176	nmav	1.3	for (i=hash;i<MODULE_HASHTABLE_SIZE;i++) {
177	nmav	1.2	if (module_hashtable[i] == NULL) break;
178	nmav	1.1
179	nmav	1.2	if ( content_type_len != module_hashtable[i]->content_type_len) continue;
180	nmav	1.1
181	nmav	1.2	if (memcmp( content_type, module_hashtable[i]->content_type,
182			content_type_len) == 0) {
183	nmav	1.1	/* FOUND! */
184	nmav	1.2	return module_hashtable[i];
185	nmav	1.1	}
186			}
187
188			return NULL;
189
190			}
191
192
193			/*
194			* Empties the hic modules table, deallocating any allocated memory.
195			*/
196
197			void dump_hic_modules(void)
198			{
199			#ifdef ENABLE_HIC
200			int i;
201
202	nmav	1.3	for (i = 0; i < MODULE_HASHTABLE_SIZE; ++i) { /* these limits OK? */
203	nmav	1.5	if (!module_hashtable[i]) continue;
204
205	nmav	1.2	free( module_hashtable[i]->sym_prefix);
206			free( module_hashtable[i]->content_type);
207			module_hashtable[i]->shutdown(); /* Run the deinitialization stuff */
208			dlclose( module_hashtable[i]->dl_handle);
209			free( module_hashtable[i]);
210			module_hashtable[i] = NULL;
211	nmav	1.1	}
212			#endif
213			}