xref: /PHP-5.3/sapi/tux/php_tux.c (revision a2045ff3)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 5                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2013 The PHP Group                                |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 3.01 of the PHP license,      |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.php.net/license/3_01.txt                                  |
11    | If you did not receive a copy of the PHP license and are unable to   |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@php.net so we can mail you a copy immediately.               |
14    +----------------------------------------------------------------------+
15    | Author: Sascha Schumann <sascha@schumann.cx>                         |
16    +----------------------------------------------------------------------+
17 */
18 
19 #include "php.h"
20 #include "SAPI.h"
21 #include "php_main.h"
22 #include "php_variables.h"
23 
24 #include "ext/standard/php_smart_str.h"
25 
26 #include "tuxmodule.h"
27 
28 #include <sys/uio.h>
29 
30 #if 0
31 #include <pthread.h>
32 #endif
33 
34 void tux_closed_conn(int fd);
35 
36 enum {
37 	PHP_TUX_BACKGROUND_CONN = 1
38 };
39 
40 typedef struct {
41 	user_req_t *req;
42 	void (*on_close)(int);
43 	int tux_action;
44 	struct iovec *header_vec;
45 	int number_vec;
46 } php_tux_globals;
47 
48 static php_tux_globals tux_globals;
49 
50 #define TG(v) (tux_globals.v)
51 
sapi_tux_ub_write(const char * str,uint str_length TSRMLS_DC)52 static int sapi_tux_ub_write(const char *str, uint str_length TSRMLS_DC)
53 {
54 	int n;
55 	int m;
56 	const char *estr;
57 
58 	/* combine headers and body */
59 	if (TG(number_vec)) {
60 		struct iovec *vec = TG(header_vec);
61 
62 		n = TG(number_vec);
63 		vec[n].iov_base = (void *) str;
64 		vec[n++].iov_len = str_length;
65 
66 		/* XXX: this might need more complete error handling */
67 		if ((m = writev(TG(req)->sock, vec, n)) == -1 && errno == EPIPE)
68 			php_handle_aborted_connection();
69 
70 		if (m > 0)
71 			TG(req)->bytes_sent += str_length;
72 
73 		TG(number_vec) = 0;
74 		return str_length;
75 	}
76 
77 	estr = str + str_length;
78 
79 	while (str < estr) {
80 		n = send(TG(req)->sock, str, estr - str, 0);
81 
82 		if (n == -1 && errno == EPIPE)
83 			php_handle_aborted_connection();
84 		if (n == -1 && errno == EAGAIN)
85 			continue;
86 		if (n <= 0)
87 			return n;
88 
89 		str += n;
90 	}
91 
92 	n = str_length - (estr - str);
93 
94 	TG(req)->bytes_sent += n;
95 
96 	return n;
97 }
98 
sapi_tux_send_headers(sapi_headers_struct * sapi_headers)99 static int sapi_tux_send_headers(sapi_headers_struct *sapi_headers)
100 {
101 	char buf[1024];
102 	struct iovec *vec;
103 	int n;
104 	int max_headers;
105 	zend_llist_position pos;
106 	sapi_header_struct *h;
107 	size_t len;
108 	char *status_line;
109 	int locate_cl;
110 	TSRMLS_FETCH();
111 
112 	max_headers = 30;
113 	n = 1;
114 
115 	vec = malloc(sizeof(struct iovec) * max_headers);
116 	status_line = malloc(30);
117 
118 	/* safe sprintf use */
119 	len = slprintf(status_line, 30, "HTTP/1.1 %d NA\r\n", SG(sapi_headers).http_response_code);
120 
121 	vec[0].iov_base = status_line;
122 	vec[0].iov_len = len;
123 
124 	TG(req)->http_status = SG(sapi_headers).http_response_code;
125 
126 	if (TG(tux_action) == TUX_ACTION_FINISH_CLOSE_REQ && TG(req)->http_version == HTTP_1_1)
127 		locate_cl = 1;
128 	else
129 		locate_cl = 0;
130 
131 	h = zend_llist_get_first_ex(&sapi_headers->headers, &pos);
132 	while (h) {
133 		if (locate_cl
134 				&& strncasecmp(h->header, "Content-length:", sizeof("Content-length:")-1) == 0) {
135 			TG(tux_action) = TUX_ACTION_FINISH_REQ;
136 			locate_cl = 0;
137 		}
138 
139 		vec[n].iov_base = h->header;
140 		vec[n++].iov_len = h->header_len;
141 		if (n >= max_headers - 3) {
142 			max_headers *= 2;
143 			vec = realloc(vec, sizeof(struct iovec) * max_headers);
144 		}
145 		vec[n].iov_base = "\r\n";
146 		vec[n++].iov_len = 2;
147 
148 		h = zend_llist_get_next_ex(&sapi_headers->headers, &pos);
149 	}
150 
151 	vec[n].iov_base = "\r\n";
152 	vec[n++].iov_len = 2;
153 
154 	TG(number_vec) = n;
155 	TG(header_vec) = vec;
156 
157 
158 	return SAPI_HEADER_SENT_SUCCESSFULLY;
159 }
160 
sapi_tux_read_post(char * buffer,uint count_bytes)161 static int sapi_tux_read_post(char *buffer, uint count_bytes)
162 {
163 #if 0
164 	int amount = 0;
165 	TSRMLS_FETCH();
166 
167 	TG(req)->objectlen = count_bytes;
168 	TG(req)->object_addr = buffer;
169 	if (tux(TUX_ACTION_READ_POST_DATA, TG(req)))
170 		return 0;
171 
172 	TG(read_post_data) = 1;
173 
174 	return TG(req)->objectlen;
175 #else
176 	return 0;
177 #endif
178 }
179 
sapi_tux_read_cookies(void)180 static char *sapi_tux_read_cookies(void)
181 {
182 	TSRMLS_FETCH();
183 
184 	return TG(req)->cookies;
185 }
186 
187 #define BUF_SIZE 512
188 #define ADD_STRING(name)										\
189 	php_register_variable(name, buf, track_vars_array TSRMLS_CC)
190 
sapi_tux_register_variables(zval * track_vars_array TSRMLS_DC)191 static void sapi_tux_register_variables(zval *track_vars_array TSRMLS_DC)
192 {
193 	char buf[BUF_SIZE + 1];
194 	char *p;
195 	sapi_header_line ctr = {0};
196 
197 	ctr.line = buf;
198 	ctr.line_len = slprintf(buf, sizeof(buf), "Server: %s", TUXAPI_version);
199 	sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
200 
201 	php_register_variable("PHP_SELF", SG(request_info).request_uri, track_vars_array TSRMLS_CC);
202 	php_register_variable("SERVER_SOFTWARE", TUXAPI_version, track_vars_array TSRMLS_CC);
203 	php_register_variable("GATEWAY_INTERFACE", "CGI/1.1", track_vars_array TSRMLS_CC);
204 	php_register_variable("REQUEST_METHOD", (char *) SG(request_info).request_method, track_vars_array TSRMLS_CC);
205 	php_register_variable("DOCUMENT_ROOT", TUXAPI_docroot, track_vars_array TSRMLS_CC);
206 	php_register_variable("SERVER_NAME", TUXAPI_servername, track_vars_array TSRMLS_CC);
207 	php_register_variable("REQUEST_URI", SG(request_info).request_uri, track_vars_array TSRMLS_CC);
208 	php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated, track_vars_array TSRMLS_CC);
209 
210 	p = inet_ntoa(TG(req)->client_host);
211 	/* string representation of IPs are never larger than 512 bytes */
212 	if (p) {
213 		memcpy(buf, p, strlen(p) + 1);
214 		ADD_STRING("REMOTE_ADDR");
215 		ADD_STRING("REMOTE_HOST");
216 	}
217 
218 	snprintf(buf, sizeof(buf), "%d", CGI_SERVER_PORT(TG(req)));
219 	ADD_STRING("SERVER_PORT");
220 
221 #if 0
222 	snprintf(buf, BUF_SIZE, "/%s", TG(hc)->pathinfo);
223 	ADD_STRING("PATH_INFO");
224 
225 	snprintf(buf, BUF_SIZE, "/%s", TG(hc)->origfilename);
226 	ADD_STRING("SCRIPT_NAME");
227 #endif
228 
229 #define CONDADD(name, field) 							\
230 	if (TG(req)->field[0]) {								\
231 		php_register_variable(#name, TG(req)->field, track_vars_array TSRMLS_CC); \
232 	}
233 
234 	CONDADD(HTTP_REFERER, referer);
235 	CONDADD(HTTP_USER_AGENT, user_agent);
236 	CONDADD(HTTP_ACCEPT, accept);
237 	CONDADD(HTTP_ACCEPT_ENCODING, accept_encoding);
238 	CONDADD(HTTP_ACCEPT_LANGUAGE, accept_language);
239 	CONDADD(HTTP_COOKIE, cookies);
240 	CONDADD(CONTENT_TYPE, content_type);
241 
242 #if 0
243 	if (TG(hc)->contentlength != -1) {
244 		snprintf(buf, sizeof(buf), "%ld", (long) TG(hc)->contentlength);
245 		ADD_STRING("CONTENT_LENGTH");
246 	}
247 #endif
248 
249 #if 0
250 	if (TG(hc)->authorization[0])
251 		php_register_variable("AUTH_TYPE", "Basic", track_vars_array TSRMLS_CC);
252 #endif
253 }
254 
255 
php_tux_startup(sapi_module_struct * sapi_module)256 static int php_tux_startup(sapi_module_struct *sapi_module)
257 {
258 	if (php_module_startup(sapi_module, NULL, 0)==FAILURE) {
259 		return FAILURE;
260 	} else {
261 		return SUCCESS;
262 	}
263 }
264 
265 static sapi_module_struct tux_sapi_module = {
266 	"tux",
267 	"tux",
268 
269 	php_tux_startup,
270 	php_module_shutdown_wrapper,
271 
272 	NULL,									/* activate */
273 	NULL,									/* deactivate */
274 
275 	sapi_tux_ub_write,
276 	NULL,
277 	NULL,									/* get uid */
278 	NULL,									/* getenv */
279 
280 	php_error,
281 
282 	NULL,
283 	sapi_tux_send_headers,
284 	NULL,
285 	sapi_tux_read_post,
286 	sapi_tux_read_cookies,
287 
288 	sapi_tux_register_variables,
289 	NULL,									/* Log message */
290 	NULL,									/* Get request time */
291 	NULL,									/* Child terminate */
292 
293 	STANDARD_SAPI_MODULE_PROPERTIES
294 };
295 
tux_module_main(TSRMLS_D)296 static void tux_module_main(TSRMLS_D)
297 {
298 	zend_file_handle file_handle;
299 
300 	file_handle.type = ZEND_HANDLE_FILENAME;
301 	file_handle.filename = SG(request_info).path_translated;
302 	file_handle.free_filename = 0;
303 	file_handle.opened_path = NULL;
304 
305 	if (php_request_startup(TSRMLS_C) == FAILURE) {
306 		return;
307 	}
308 
309 	php_execute_script(&file_handle TSRMLS_CC);
310 	php_request_shutdown(NULL);
311 }
312 
tux_request_ctor(TSRMLS_D)313 static void tux_request_ctor(TSRMLS_D)
314 {
315 	char buf[1024];
316 	int offset;
317 	size_t filename_len;
318 	size_t cwd_len;
319 	smart_str s = {0};
320 	char *p;
321 
322 	TG(number_vec) = 0;
323 	TG(header_vec) = NULL;
324 	SG(request_info).query_string = strdup(TG(req)->query);
325 
326 	smart_str_appends_ex(&s, "/", 1);
327 	smart_str_appends_ex(&s, TG(req)->query, 1);
328 	smart_str_0(&s);
329 	p = strchr(s.c, '&');
330 	if (p)
331 		*p = '\0';
332 	SG(request_info).path_translated = s.c;
333 
334 	s.c = NULL;
335 	smart_str_appendc_ex(&s, '/', 1);
336 	smart_str_appends_ex(&s, TG(req)->objectname, 1);
337 	smart_str_0(&s);
338 	SG(request_info).request_uri = s.c;
339 	SG(request_info).request_method = CGI_REQUEST_METHOD(TG(req));
340 	if(TG(req)->http_version == HTTP_1_1) SG(request_info).proto_num = 1001;
341 	else SG(request_info).proto_num = 1000;
342 	SG(sapi_headers).http_response_code = 200;
343 	SG(request_info).content_type = TG(req)->content_type;
344 	SG(request_info).content_length = 0; /* TG(req)->contentlength; */
345 
346 #if 0
347 	php_handle_auth_data(TG(hc)->authorization TSRMLS_CC);
348 #endif
349 }
350 
tux_request_dtor(TSRMLS_D)351 static void tux_request_dtor(TSRMLS_D)
352 {
353 	if (TG(header_vec)) {
354 		/* free status_line */
355 		free(TG(header_vec)[0].iov_base);
356 		free(TG(header_vec));
357 	}
358 	if (SG(request_info).query_string)
359 		free(SG(request_info).query_string);
360 	free(SG(request_info).request_uri);
361 	free(SG(request_info).path_translated);
362 }
363 
364 #if 0
365 static void *separate_thread(void *bla)
366 {
367 	int fd;
368 	int i = 0;
369 
370 	fd = (int) bla;
371 
372 	while (i++ < 5) {
373 		send(fd, "test<br />\n", 9, 0);
374 		sleep(1);
375 	}
376 
377 	tux(TUX_ACTION_CONTINUE_REQ, (user_req_t *) fd);
378 	/* We HAVE to trigger some event on the fd. Otherwise
379 	   fast_thread won't wake up, so that the eventloop
380 	   won't be entered -> TUX hangs */
381 	shutdown(fd, 2);
382 	pthread_exit(NULL);
383 }
384 #endif
385 
TUXAPI_handle_events(user_req_t * req)386 int TUXAPI_handle_events(user_req_t *req)
387 {
388 	TSRMLS_FETCH();
389 
390 	if (req->event == PHP_TUX_BACKGROUND_CONN) {
391 		tux_closed_conn(req->sock);
392 		return tux(TUX_ACTION_FINISH_CLOSE_REQ, req);
393 	}
394 
395 	TG(req) = req;
396 	TG(tux_action) = TUX_ACTION_FINISH_CLOSE_REQ;
397 
398 	tux_request_ctor(TSRMLS_C);
399 
400 	tux_module_main(TSRMLS_C);
401 
402 	tux_request_dtor(TSRMLS_C);
403 
404 	return tux(TG(tux_action), req);
405 }
406 
tux_register_on_close(void (* arg)(int))407 void tux_register_on_close(void (*arg)(int))
408 {
409 	TG(on_close) = arg;
410 }
411 
tux_closed_conn(int fd)412 void tux_closed_conn(int fd)
413 {
414 	TSRMLS_FETCH();
415 
416 	if (TG(on_close)) TG(on_close)(fd);
417 }
418 
tux_get_fd(void)419 int tux_get_fd(void)
420 {
421 	TSRMLS_FETCH();
422 
423 	return TG(req)->sock;
424 }
425 
tux_set_dont_close(void)426 void tux_set_dont_close(void)
427 {
428 	TSRMLS_FETCH();
429 
430 	TG(req)->event = PHP_TUX_BACKGROUND_CONN;
431 	tux(TUX_ACTION_POSTPONE_REQ, TG(req));
432 	TG(tux_action) = TUX_ACTION_EVENTLOOP;
433 }
434 
TUXAPI_init(void)435 void TUXAPI_init(void)
436 {
437 	sapi_startup(&tux_sapi_module);
438 	tux_sapi_module.startup(&tux_sapi_module);
439 	SG(server_context) = (void *) 1;
440 }
441 
doesnotmatter_fini(void)442 void doesnotmatter_fini(void)
443 {
444 	if (SG(server_context) != NULL) {
445 		tux_sapi_module.shutdown(&tux_sapi_module);
446 		sapi_shutdown();
447 	}
448 }
449 
450 /*
451  * Local variables:
452  * tab-width: 4
453  * c-basic-offset: 4
454  * End:
455  * vim600: sw=4 ts=4 fdm=marker
456  * vim<600: sw=4 ts=4
457  */
458