hydra/src/hic.c

/*
 * Copyright (C) 2002 Nikos Mavroyanopoulos
 *
 * This file is part of BOA webserver.
 *
 * Hydra 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 2 of the License, or
 * (at your option) any later version.
 *
 * Hydra 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include "boa.h"
#include <signal.h>             /* signal */

/* Hydra Internally handled CGIs (HIC HIC)
 *
 * How does it work?
 *
 * A special thread (maybe more than one), is used for CGIs. This tread
 * uses one pipe to communicate with the others via hic_send_command().
 *
 * If a request for a HIC file arrives, the server goes as a normal CGI 
 * creates a pipe, but does not fork. It enqueues a hic_request
 * for this (HIC) thread, and sends a SIGUSR2 signal. The HIC thread is then
 * waken up, and handles all pending requests.
 *
 * The HIC thread, when receives the message, parses the CGIs,
 * one CGI at the time, and sends the output to fd.
 *
 * The benefit is that in no case the server is blocked. We may have
 * a performance problem, if the server only uses parsed CGIs.
 *
 */

#ifdef ENABLE_HIC

#include "hic.h"

#ifdef ENABLE_SMP
pthread_mutex_t hic_lock = PTHREAD_MUTEX_INITIALIZER;
#endif

typedef struct _hic_request {
   struct _hic_request *next;
   struct _hic_request *prev;
   hic_stuff command;
} hic_request;

hic_request * hic_request_head = NULL;

static int process_hic_request(hic_request * cmd);
void hic_dequeue(hic_request ** head, hic_request * req);
void hic_enqueue(hic_request ** head, hic_request * req);
int hic_sigchld_flag = 0; /* if we received a SIGCHLD signal, then this flag 
                        * is non zero */

void *hic_main_loop(void *cml)
{
   hic_request* current, *next;

   while (1) {
      for (current = hic_request_head;current;current=next) {

#ifdef ENABLE_SMP
         pthread_mutex_lock(&hic_lock);
#endif
         next = current->next;
#ifdef ENABLE_SMP
         pthread_mutex_unlock(&hic_lock);
#endif

         if (process_hic_request( current) == -1) {
            log_error_time();
            fprintf(stderr, "hic: Error while processing command.\n");
            exit(1);
         }
      }
      
      /* If somebody sends a command, then he should
       * send a sigusr2 as well.
       */
      unblock_sigusr2();
      if (!hic_request_head) pause();
      block_sigusr2();

      if (hic_sigchld_flag)
         sigchld_run();
      

   }

}

static int process_hic_request(hic_request * req)
{
   hic_module_st *hst;
   hic_stuff* cmd = &req->command;
   
#ifdef ENABLE_SMP
   pthread_mutex_lock(&hic_lock);
#endif
   hic_dequeue( &hic_request_head, req);
#ifdef ENABLE_SMP
   pthread_mutex_unlock(&hic_lock);
#endif

   hst = find_hic_appr_module(get_mime_type(cmd->path_translated), 0);
   if (hst == NULL) {
      log_error_time();
      fprintf(stderr, "Could not find HIC handler for '%s'\n",
              cmd->path_translated);
      close(cmd->out_fd);
      free( req);
      return 0;
   }

   hst->request(cmd);
   close(cmd->out_fd);
   free( req);

/*
   log_error_time();
   fprintf(stderr, "HIC status: %d wrote: %d\n", cmd->status, cmd->bytes_sent);
 */

   return 0;
}

/* Sends a command to a HIC thread.
 */
int hic_send_command(request * req, int out_fd)
{
   hic_request *x;

   x = malloc( sizeof( hic_request));
   if (x==NULL)
      return -1;

   x->next = x->prev = NULL;
   x->command.cgi_env = req->cgi_env;
   x->command.cgi_env_max = req->cgi_env_index;
   x->command.one_one = 0;
   x->command.post_data_fd = req->post_data_fd;
   x->command.out_fd = out_fd;
   x->command.request_uri = req->request_uri;
   x->command.path_translated = req->path_translated;

#ifdef ENABLE_SMP
   pthread_mutex_lock(&hic_lock);
#endif
   
   hic_enqueue( &hic_request_head, x);
#ifdef ENABLE_SMP
   /* Notify the main loop */
   pthread_kill( hic_tid, SIGUSR2);
#endif

#ifdef ENABLE_SMP
   pthread_mutex_unlock(&hic_lock);
#endif

   return 1;

}

/* Implement a basic queue for HIC stuff. This is created after
 * queue.c.
 */

#include "queue.h" 

ENQUEUE_FUNCTION( hic_enqueue, hic_request)
DEQUEUE_FUNCTION( hic_dequeue, hic_request)

#endif  /* ENABLE_HIC */
1	nmav	1.1	/*
2			* Copyright (C) 2002 Nikos Mavroyanopoulos
3			*
4			* This file is part of BOA webserver.
5			*
6	nmav	1.7	* Hydra is free software; you can redistribute it and/or modify
7	nmav	1.1	* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11	nmav	1.7	* Hydra is distributed in the hope that it will be useful,
12	nmav	1.1	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include "boa.h"
22	nmav	1.5	#include <signal.h> /* signal */
23	nmav	1.1
24	nmav	1.2	/* Hydra Internally handled CGIs (HIC HIC)
25			*
26			* How does it work?
27			*
28			* A special thread (maybe more than one), is used for CGIs. This tread
29			* uses one pipe to communicate with the others via hic_send_command().
30			*
31			* If a request for a HIC file arrives, the server goes as a normal CGI
32	nmav	1.5	* creates a pipe, but does not fork. It enqueues a hic_request
33			* for this (HIC) thread, and sends a SIGUSR2 signal. The HIC thread is then
34			* waken up, and handles all pending requests.
35	nmav	1.2	*
36	nmav	1.5	* The HIC thread, when receives the message, parses the CGIs,
37			* one CGI at the time, and sends the output to fd.
38	nmav	1.2	*
39			* The benefit is that in no case the server is blocked. We may have
40	nmav	1.5	* a performance problem, if the server only uses parsed CGIs.
41			*
42	nmav	1.2	*/
43
44	nmav	1.1	#ifdef ENABLE_HIC
45
46			#include "hic.h"
47
48	nmav	1.5	#ifdef ENABLE_SMP
49			pthread_mutex_t hic_lock = PTHREAD_MUTEX_INITIALIZER;
50			#endif
51
52			typedef struct _hic_request {
53			struct _hic_request *next;
54			struct _hic_request *prev;
55			hic_stuff command;
56			} hic_request;
57
58			hic_request * hic_request_head = NULL;
59
60			static int process_hic_request(hic_request * cmd);
61			void hic_dequeue(hic_request ** head, hic_request * req);
62			void hic_enqueue(hic_request ** head, hic_request * req);
63			int hic_sigchld_flag = 0; /* if we received a SIGCHLD signal, then this flag
64			* is non zero */
65	nmav	1.1
66	nmav	1.5	void hic_main_loop(void cml)
67	nmav	1.1	{
68	nmav	1.5	hic_request* current, *next;
69	nmav	1.1
70			while (1) {
71	nmav	1.5	for (current = hic_request_head;current;current=next) {
72	nmav	1.1
73	nmav	1.5	#ifdef ENABLE_SMP
74			pthread_mutex_lock(&hic_lock);
75			#endif
76			next = current->next;
77			#ifdef ENABLE_SMP
78			pthread_mutex_unlock(&hic_lock);
79			#endif
80	nmav	1.1
81	nmav	1.5	if (process_hic_request( current) == -1) {
82	nmav	1.1	log_error_time();
83			fprintf(stderr, "hic: Error while processing command.\n");
84			exit(1);
85			}
86			}
87	nmav	1.5
88			/* If somebody sends a command, then he should
89			* send a sigusr2 as well.
90			*/
91	nmav	1.6	unblock_sigusr2();
92	nmav	1.5	if (!hic_request_head) pause();
93	nmav	1.6	block_sigusr2();
94	nmav	1.5
95			if (hic_sigchld_flag)
96			sigchld_run();
97
98	nmav	1.1
99			}
100
101			}
102
103	nmav	1.5	static int process_hic_request(hic_request * req)
104	nmav	1.1	{
105	nmav	1.5	hic_module_st *hst;
106			hic_stuff* cmd = &req->command;
107
108			#ifdef ENABLE_SMP
109			pthread_mutex_lock(&hic_lock);
110			#endif
111			hic_dequeue( &hic_request_head, req);
112			#ifdef ENABLE_SMP
113			pthread_mutex_unlock(&hic_lock);
114			#endif
115	nmav	1.3
116	nmav	1.5	hst = find_hic_appr_module(get_mime_type(cmd->path_translated), 0);
117	nmav	1.3	if (hst == NULL) {
118			log_error_time();
119	nmav	1.5	fprintf(stderr, "Could not find HIC handler for '%s'\n",
120			cmd->path_translated);
121			close(cmd->out_fd);
122			free( req);
123	nmav	1.3	return 0;
124			}
125
126	nmav	1.5	hst->request(cmd);
127			close(cmd->out_fd);
128			free( req);
129	nmav	1.1
130	nmav	1.3	/*
131	nmav	1.1	log_error_time();
132			fprintf(stderr, "HIC status: %d wrote: %d\n", cmd->status, cmd->bytes_sent);
133	nmav	1.3	*/
134	nmav	1.1
135			return 0;
136			}
137
138	nmav	1.5	/* Sends a command to a HIC thread.
139			*/
140			int hic_send_command(request * req, int out_fd)
141	nmav	1.1	{
142	nmav	1.5	hic_request *x;
143	nmav	1.1
144	nmav	1.5	x = malloc( sizeof( hic_request));
145			if (x==NULL)
146			return -1;
147
148			x->next = x->prev = NULL;
149			x->command.cgi_env = req->cgi_env;
150			x->command.cgi_env_max = req->cgi_env_index;
151			x->command.one_one = 0;
152			x->command.post_data_fd = req->post_data_fd;
153			x->command.out_fd = out_fd;
154			x->command.request_uri = req->request_uri;
155			x->command.path_translated = req->path_translated;
156	nmav	1.1
157			#ifdef ENABLE_SMP
158	nmav	1.5	pthread_mutex_lock(&hic_lock);
159	nmav	1.1	#endif
160	nmav	1.5
161			hic_enqueue( &hic_request_head, x);
162	nmav	1.1	#ifdef ENABLE_SMP
163	nmav	1.5	/* Notify the main loop */
164			pthread_kill( hic_tid, SIGUSR2);
165	nmav	1.1	#endif
166
167			#ifdef ENABLE_SMP
168	nmav	1.5	pthread_mutex_unlock(&hic_lock);
169	nmav	1.1	#endif
170
171	nmav	1.5	return 1;
172	nmav	1.1
173			}
174
175	nmav	1.5	/* Implement a basic queue for HIC stuff. This is created after
176			* queue.c.
177			*/
178	nmav	1.1
179	nmav	1.5	#include "queue.h"
180	nmav	1.1
181	nmav	1.5	ENQUEUE_FUNCTION( hic_enqueue, hic_request)
182			DEQUEUE_FUNCTION( hic_dequeue, hic_request)
183	nmav	1.1
184	nmav	1.5	#endif /* ENABLE_HIC */