author | Dan |
Wed, 24 Sep 2008 13:47:42 -0400 | |
changeset 54 | 6d8b9497e44b |
parent 53 | a6b339665650 |
child 56 | 53b0f0d7ff6f |
permissions | -rw-r--r-- |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1 |
<?php |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
3 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
4 |
* Webserver class |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
5 |
* |
6
5f35ebc4f9bb
First release version. Renamed to Greyhound and readme/license files added.
Dan
parents:
5
diff
changeset
|
6 |
* Greyhound - real web management for Amarok |
5
9b96265b5918
Relicensed to GPLv2. Previous revisions should not be downloaded as they do not contain copies of appropriate licenses, which will be added in a later commit. Completed interface for mobile devices.
Dan
parents:
0
diff
changeset
|
7 |
* Copyright (C) 2008 Dan Fuhry |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
8 |
* |
5
9b96265b5918
Relicensed to GPLv2. Previous revisions should not be downloaded as they do not contain copies of appropriate licenses, which will be added in a later commit. Completed interface for mobile devices.
Dan
parents:
0
diff
changeset
|
9 |
* This program is Free Software; you can redistribute and/or modify it under the terms of the GNU General Public License |
9b96265b5918
Relicensed to GPLv2. Previous revisions should not be downloaded as they do not contain copies of appropriate licenses, which will be added in a later commit. Completed interface for mobile devices.
Dan
parents:
0
diff
changeset
|
10 |
* as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. |
9b96265b5918
Relicensed to GPLv2. Previous revisions should not be downloaded as they do not contain copies of appropriate licenses, which will be added in a later commit. Completed interface for mobile devices.
Dan
parents:
0
diff
changeset
|
11 |
* |
9b96265b5918
Relicensed to GPLv2. Previous revisions should not be downloaded as they do not contain copies of appropriate licenses, which will be added in a later commit. Completed interface for mobile devices.
Dan
parents:
0
diff
changeset
|
12 |
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
9b96265b5918
Relicensed to GPLv2. Previous revisions should not be downloaded as they do not contain copies of appropriate licenses, which will be added in a later commit. Completed interface for mobile devices.
Dan
parents:
0
diff
changeset
|
13 |
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for details. |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
14 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
15 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
16 |
require('multithreading.php'); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
17 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
18 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
19 |
* Version of the server |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
20 |
* @const string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
21 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
22 |
|
43 | 23 |
define('HTTPD_VERSION', '0.1b5'); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
24 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
25 |
/** |
26
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
26 |
* Length of keep-alive connections |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
27 |
* @const int |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
28 |
*/ |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
29 |
|
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
30 |
define('HTTPD_KEEP_ALIVE_TIMEOUT', 300); |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
31 |
|
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
32 |
/** |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
33 |
* Webserver system icons |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
34 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
35 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
36 |
define('HTTPD_ICON_SCRIPT', 'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAGSSURBVCjPVVFNSwJhEF78Ad79Cf6PvXQRsotUlzKICosuRYmR2RJR0KE6lBFFZVEbpFBSqKu2rum6llFS9HHI4iUhT153n6ZtIWMOM+/MM88z7wwH7s9Ub16SJcnbmrNcxVm2q7Z8/QPvEOtntpj92NkCqITLepEpjix7xQtiLOoQ2b6+E7YAN/5nfOEJ2WbKqOIOJ4bYVMEQx4LfBBQDsvFMhUcCVU1/CxVXmDBGA5ZETrhDCQVcYAPbyEJBhvrnBVPiSpNr6cYDNCQwo4zzU/ySckkgDYuNuVpI42T9k4gLKGMPs/xPzzovQiY2hQYe0jlJfyNNhTqiWDYBq/wBMcSRpnyPzu1oS7WtxjVBSthU1vgVksiQ3Dn6Gp5ah2YOKQo5GiuHPA6xT1EKpxQNCNYejgIR457KKio0S56YckjSa9jo//3mrj+BV0QQagqGTOo+Y7gZIf1puP3WHoLhEb2PjTlCTCWGXtbp8DCX3hZuOdaIc9A+aQvWk4ihq95p67a7nP+u+Ws+r0dql9z/zv0NCYhdCPKZ7oYAAAAASUVORK5CYII='); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
37 |
define('HTTPD_ICON_FOLDER', 'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAGrSURBVDjLxZO7ihRBFIa/6u0ZW7GHBUV0UQQTZzd3QdhMQxOfwMRXEANBMNQX0MzAzFAwEzHwARbNFDdwEd31Mj3X7a6uOr9BtzNjYjKBJ6nicP7v3KqcJFaxhBVtZUAK8OHlld2st7Xl3DJPVONP+zEUV4HqL5UDYHr5xvuQAjgl/Qs7TzvOOVAjxjlC+ePSwe6DfbVegLVuT4r14eTr6zvA8xSAoBLzx6pvj4l+DZIezuVkG9fY2H7YRQIMZIBwycmzH1/s3F8AapfIPNF3kQk7+kw9PWBy+IZOdg5Ug3mkAATy/t0usovzGeCUWTjCz0B+Sj0ekfdvkZ3abBv+U4GaCtJ1iEm6ANQJ6fEzrG/engcKw/wXQvEKxSEKQxRGKE7Izt+DSiwBJMUSm71rguMYhQKrBygOIRStf4TiFFRBvbRGKiQLWP29yRSHKBTtfdBmHs0BUpgvtgF4yRFR+NUKi0XZcYjCeCG2smkzLAHkbRBmP0/Uk26O5YnUActBp1GsAI+S5nRJJJal5K1aAMrq0d6Tm9uI6zjyf75dAe6tx/SsWeD//o2/Ab6IH3/h25pOAAAAAElFTkSuQmCC'); |
29 | 38 |
define('HTTPD_ICON_FILE', 'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAINSURBVBgZBcG/r55zGAfg6/4+z3va01NHlYgzEfE7MdCIGISFgS4Gk8ViYyM2Mdlsko4GSf8Do0FLRCIkghhYJA3aVBtEz3nP89wf11VJvPDepdd390+8Nso5nESBQoq0pfvXm9fzWf19453LF85vASqJlz748vInb517dIw6EyYBIIG49u+xi9/c9MdvR//99MPPZ7+4cP4IZhhTPbwzT2d+vGoaVRRp1rRliVvHq+cfvM3TD82+7mun0o/ceO7NT+/4/KOXjwZU1ekk0840bAZzMQ2mooqh0A72d5x/6sB9D5zYnff3PoYBoWBgFKPKqDKqjCpjKr//dcu9p489dra88cydps30KswACfNEKanSaxhlntjJ8Mv12Paie+vZ+0+oeSwwQ0Iw1xAR1CiFNJkGO4wu3ZMY1AAzBI0qSgmCNJsJUEOtJSMaCTBDLyQ0CknAGOgyTyFFiLI2awMzdEcSQgSAAKVUmAeNkxvWJWCGtVlDmgYQ0GFtgg4pNtOwbBcwQy/Rife/2yrRRVI0qYCEBly8Z+P4qMEMy7JaVw72N568e+iwhrXoECQkfH91kY7jwwXMsBx1L93ZruqrK6uuiAIdSnTIKKPLPFcvay8ww/Hh+ufeznTXu49v95IMoQG3784gYXdTqvRmqn/Wpa/ADFX58MW3L71SVU9ETgEIQQQIOOzub+fhIvwPRDgeVjWDahIAAAAASUVORK5CYII='); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
39 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
40 |
/** |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
41 |
* Abstraction layer to use |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
42 |
*/ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
43 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
44 |
define('HTTPD_SOCKET_LAYER', 'Stream'); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
45 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
46 |
/** |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
47 |
* Simple but full-featured embedded web server written in PHP. |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
48 |
* @package Amarok |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
49 |
* @subpackage WebControl |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
50 |
* @author Dan Fuhry |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
51 |
* @license GNU General Public License <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html> |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
52 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
53 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
54 |
class WebServer |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
55 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
56 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
57 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
58 |
* IP address we're bound to |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
59 |
* @var string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
60 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
61 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
62 |
var $bind_address = '127.0.0.1'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
63 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
64 |
/** |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
65 |
* Port we're listening on |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
66 |
* @var int |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
67 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
68 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
69 |
var $port = 8080; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
70 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
71 |
/** |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
72 |
* Socket abstraction object |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
73 |
* @var object |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
74 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
75 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
76 |
var $server = null; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
77 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
78 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
79 |
* Server string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
80 |
* @var string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
81 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
82 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
83 |
var $server_string = 'PhpHttpd'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
84 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
85 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
86 |
* Default document (well default handler) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
87 |
* @var string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
88 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
89 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
90 |
var $default_document = false; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
91 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
92 |
/** |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
93 |
* List of filenames or handlers used when a directory listing is requested |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
94 |
* @var array |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
95 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
96 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
97 |
var $directory_index = array('index.html', 'index.htm', 'index', 'default.html', 'default.htm'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
98 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
99 |
/** |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
100 |
* HTTP response code set by the handler function |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
101 |
* @var int |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
102 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
103 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
104 |
var $response_code = 0; |
40
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
105 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
106 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
107 |
* Content type set by the current handler function |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
108 |
* @var string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
109 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
110 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
111 |
var $content_type = ''; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
112 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
113 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
114 |
* Response headers to send back to the client |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
115 |
* @var array |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
116 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
117 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
118 |
var $response_headers = array(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
119 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
120 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
121 |
* List of handlers |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
122 |
* @var array |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
123 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
124 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
125 |
var $handlers = array(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
126 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
127 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
128 |
* Switch to control if directory listing is enabled |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
129 |
* @var bool |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
130 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
131 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
132 |
var $allow_dir_list = false; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
133 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
134 |
/** |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
135 |
* Switch to control forking support. |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
136 |
* @var bool |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
137 |
*/ |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
138 |
|
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
139 |
var $allow_fork = true; |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
140 |
|
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
141 |
/** |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
142 |
* Multi-threading manager. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
143 |
* @var object |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
144 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
145 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
146 |
var $threader = false; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
147 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
148 |
/** |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
149 |
* Keep-alive support uses this to track what the client requested. |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
150 |
* Only used if $allow_fork is set to true. |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
151 |
* @var bool |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
152 |
*/ |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
153 |
|
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
154 |
var $in_keepalive = false; |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
155 |
|
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
156 |
/** |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
157 |
* UUID for this server instance |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
158 |
* @var string |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
159 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
160 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
161 |
var $uuid = '00000000-0000-0000-0000-000000000000'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
162 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
163 |
/** |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
164 |
* Switch to track whether a scriptlet is running. If it is, send_http_error() does more than normal. |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
165 |
* @var bool |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
166 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
167 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
168 |
var $in_scriptlet = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
169 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
170 |
/** |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
171 |
* Switch to track whether headers have been sent or not. |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
172 |
* @var bool |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
173 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
174 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
175 |
var $headers_sent = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
176 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
177 |
/** |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
178 |
* Switch to track if the socket is bound and thus needs to be freed or not |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
179 |
* @var bool |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
180 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
181 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
182 |
var $socket_initted = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
183 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
184 |
/** |
32
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
185 |
* The list of child processes spawned by this server. |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
186 |
* @var array |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
187 |
*/ |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
188 |
|
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
189 |
var $child_list = array(); |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
190 |
|
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
191 |
/** |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
192 |
* The parent process's PID |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
193 |
* @var int |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
194 |
*/ |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
195 |
|
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
196 |
var $parent_pid = 0; |
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
197 |
|
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
198 |
/** |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
199 |
* List of IPC request handlers |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
200 |
* @var array |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
201 |
* @access private |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
202 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
203 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
204 |
var $ipc_handlers = array(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
205 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
206 |
/** |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
207 |
* Sockets for parent and child to communicate |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
208 |
* @var resource |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
209 |
* @var resource |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
210 |
*/ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
211 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
212 |
var $parent_sock = null; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
213 |
var $child_sock = null; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
214 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
215 |
/** |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
216 |
* Switched on when a graceful reboot event is sent. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
217 |
* @var bool |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
218 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
219 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
220 |
var $reboot_sent = false; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
221 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
222 |
/** |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
223 |
* Constructor. |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
224 |
* @param string IPv4 address to bind to |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
225 |
* @param int Port number |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
226 |
* @param int If port is under 1024, specify a user ID/name to switch to here |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
227 |
* @param int If port is under 1024, specify a group ID/name to switch to here |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
228 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
229 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
230 |
function __construct($address = '127.0.0.1', $port = 8080, $targetuser = null, $targetgroup = null) |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
231 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
232 |
@set_time_limit(0); |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
233 |
@ini_set('memory_limit', '128M'); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
234 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
235 |
// make sure we're not running as root |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
236 |
// note that if allow_root is true, you must specify a UID/GID (or user/group) to switch to once the socket is bound |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
237 |
$allow_root = ( $port < 1024 ) ? true : false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
238 |
if ( function_exists('posix_geteuid') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
239 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
240 |
$euid = posix_geteuid(); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
241 |
$egid = posix_getegid(); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
242 |
$username = posix_getpwuid($euid); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
243 |
$username = $username['name']; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
244 |
$group = posix_getgrgid($egid); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
245 |
$group = $group['name']; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
246 |
if ( $euid == 0 && !$allow_root ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
247 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
248 |
// running as root but not on a privileged port - die for security |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
249 |
burnout("Running as superuser (user \"$username\" and group \"$group\"). This is not allowed for security reasons."); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
250 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
251 |
else if ( $euid == 0 && $allow_root ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
252 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
253 |
// running as root and port below 1024, so notify of the switch and verify that a target UID and GID were passed |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
254 |
if ( $targetuser === null || $targetgroup === null ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
255 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
256 |
// no target user/group specified |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
257 |
burnout("Must specify a target user and group when running server as root"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
258 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
259 |
// get info about target user/group |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
260 |
if ( is_string($targetuser) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
261 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
262 |
$targetuser = posix_getpwnam($targetuser); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
263 |
$targetuser = $targetuser['uid']; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
264 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
265 |
if ( is_string($targetgroup) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
266 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
267 |
$targetgroup = posix_getgrnam($targetgroup); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
268 |
$targetgroup = $targetgroup['uid']; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
269 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
270 |
// make sure all info is valid |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
271 |
if ( !is_int($targetuser) || !is_int($targetgroup) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
272 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
273 |
burnout('Invalid user or group specified'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
274 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
275 |
$userinfo = posix_getpwuid($targetuser); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
276 |
$groupinfo = posix_getgrgid($targetgroup); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
277 |
if ( function_exists('status') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
278 |
status("Will switch to user \"{$userinfo['name']}\" and group \"{$groupinfo['name']}\" shortly after binding to socket"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
279 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
280 |
else if ( $allow_root && $euid > 0 ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
281 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
282 |
burnout("Must be superuser to bind to ports below 1024"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
283 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
284 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
285 |
$socket_do_root = ( $allow_root ) ? function_exists('posix_geteuid') : false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
286 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
287 |
$class = 'Socket_' . HTTPD_SOCKET_LAYER; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
288 |
$this->server = new $class(); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
289 |
$this->server->tcp_listen($address, $port); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
290 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
291 |
// if running as root and we made it here, switch credentials |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
292 |
if ( $socket_do_root ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
293 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
294 |
posix_setuid($targetuser); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
295 |
posix_setgid($targetgroup); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
296 |
posix_setegid($targetgroup); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
297 |
posix_seteuid($targetuser); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
298 |
if ( function_exists('status') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
299 |
status('Successfully switched user ID'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
300 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
301 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
302 |
$this->bind_address = $address; |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
303 |
$this->port = $port; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
304 |
$this->server_string = "PhpHttpd/" . HTTPD_VERSION . " PHP/" . PHP_VERSION . "\r\n"; |
32
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
305 |
$this->parent_pid = getmypid(); |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
306 |
$this->threader = new Threader(); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
307 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
308 |
// create a UUID |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
309 |
$uuid_base = md5(microtime() . ( function_exists('mt_rand') ? mt_rand() : rand() )); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
310 |
$this->uuid = substr($uuid_base, 0, 8) . '-' . |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
311 |
substr($uuid_base, 8, 4) . '-' . |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
312 |
substr($uuid_base, 12, 4) . '-' . |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
313 |
substr($uuid_base, 16, 4) . '-' . |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
314 |
substr($uuid_base, 20, 20); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
315 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
316 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
317 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
318 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
319 |
* Destructor. |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
320 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
321 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
322 |
function __destruct() |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
323 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
324 |
if ( !$this->threader->is_child() && $this->socket_initted ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
325 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
326 |
if ( function_exists('status') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
327 |
status('WebServer: destroying socket'); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
328 |
$this->server->destroy(); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
329 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
330 |
// tell all children to shut down |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
331 |
if ( $this->allow_fork ) |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
332 |
{ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
333 |
if ( function_exists('status') ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
334 |
status('WebServer: asking all children to exit'); |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
335 |
$this->threader->kill_all_children(); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
336 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
337 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
338 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
339 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
340 |
/** |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
341 |
* Reboot the server. Useful for applying new settings. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
342 |
* @param string Optional, new IP address to bind to |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
343 |
* @param int Optional, new port to bind to |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
344 |
* @param bool Optional, whether to allow forking or not |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
345 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
346 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
347 |
function reboot($addr = null, $port = null, $allow_fork = null) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
348 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
349 |
if ( function_exists('status') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
350 |
status('Reboot request has been received'); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
351 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
352 |
$addr = ( !is_string($addr) ) ? $this->bind_address : $addr; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
353 |
$port = ( !is_int($port) ) ? $this->port : $port; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
354 |
$fork = ( !is_bool($allow_fork) ) ? $this->allow_fork : $allow_fork; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
355 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
356 |
// |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
357 |
// REBOOTING IS A COMPLICATED THING. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
358 |
// We need to ask all children to close any existing connections so |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
359 |
// that all relevant socket resources can be freed. Then we need to |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
360 |
// call the constructor again to respawn the server, and finally |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
361 |
// re-enter the server loop. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
362 |
// |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
363 |
// However, reboot() is often called from a PHP-based handler. This |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
364 |
// means that some config page probably still needs to be sent. What |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
365 |
// we can do here is send an IPC event that fires the actual reboot, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
366 |
// then return to allow the current page to finish up. We also need |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
367 |
// to signal the current process to shut down any existing keep- |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
368 |
// alive connections. This can be accomplished by setting in_keepalive |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
369 |
// to false. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
370 |
// |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
371 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
372 |
// Kill the entire child after this response is sent |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
373 |
$this->in_keepalive = false; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
374 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
375 |
// If we're the parent process, we need to know that a reboot event |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
376 |
// was fired, and thus the server's main socket needs to be destroyed |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
377 |
// and recreated. This is just done with another boolean switch. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
378 |
$this->reboot_sent = true; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
379 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
380 |
// this is really to track if there are any children |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
381 |
$oldfork = $this->allow_fork; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
382 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
383 |
// Set our new server flags |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
384 |
$this->bind_address = $addr; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
385 |
$this->port = $port; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
386 |
$this->allow_fork = $fork; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
387 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
388 |
// If we're a child, we have to tell the parent what the hell is |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
389 |
// going on, and then get out of here as quickly as possible |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
390 |
// (and other children should do the same). If this is a child, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
391 |
// fire an IPC reboot event. Else, fire a "die all" event |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
392 |
if ( $this->threader->is_child() ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
393 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
394 |
if ( function_exists('status') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
395 |
status('Signaling parent with parameter changes (fork = ' . intval($fork) . ') + reboot request'); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
396 |
// this is the child |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
397 |
$this->threader->ipc_send(array( |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
398 |
'action' => 'ws_reboot', |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
399 |
'addr' => $addr, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
400 |
'port' => $port, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
401 |
'fork' => $fork |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
402 |
)); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
403 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
404 |
else if ( !$this->threader->is_child() && $oldfork ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
405 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
406 |
if ( function_exists('status') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
407 |
status('Waiting on all children'); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
408 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
409 |
// this is the parent, and there are children present |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
410 |
$this->threader->kill_all_children(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
411 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
412 |
// all children are dead, we are ok to respawn |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
413 |
$this->respawn(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
414 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
415 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
416 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
417 |
// this is a childless parent; delay any action until the current |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
418 |
// request has been sent (do nothing now) |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
419 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
420 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
421 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
422 |
/** |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
423 |
* Respawns the server. All children should be dead, and any client |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
424 |
* connections must be closed. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
425 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
426 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
427 |
function respawn() |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
428 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
429 |
$this->reboot_sent = false; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
430 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
431 |
if ( function_exists('status') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
432 |
status('Respawn event sent'); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
433 |
$this->server->destroy(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
434 |
unset($this->server); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
435 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
436 |
// try to spawn up to 10 times |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
437 |
for ( $i = 0; $i < 10; $i++ ) |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
438 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
439 |
try |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
440 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
441 |
$this->__construct($this->bind_address, $this->port); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
442 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
443 |
catch ( Exception $e ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
444 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
445 |
if ( $i == 9 ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
446 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
447 |
if ( function_exists('burnout') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
448 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
449 |
burnout("Couldn't respawn because one of the child processes did not die, and thus the port was not freed."); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
450 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
451 |
exit(1); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
452 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
453 |
if ( function_exists('status') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
454 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
455 |
status("Respawn failed, retrying in 2 seconds"); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
456 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
457 |
usleep(2000000); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
458 |
continue; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
459 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
460 |
break; |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
461 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
462 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
463 |
if ( function_exists('status') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
464 |
status('Respawn is complete, entering server loop with bind_address = ' . $this->bind_address . ' allow_fork = ' . strval(intval($this->allow_fork))); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
465 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
466 |
// all handlers should already be set up, so just break out and we should automatically continue the server loop |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
467 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
468 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
469 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
470 |
* Main server loop |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
471 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
472 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
473 |
function serve() |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
474 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
475 |
while ( true ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
476 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
477 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
478 |
## STAGE 0: CLEANUP FROM PREVIOUS RUN |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
479 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
480 |
|
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
481 |
// if this is a child process, we're finished - close up shop |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
482 |
if ( $this->threader->is_child() && !$this->in_keepalive ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
483 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
484 |
if ( function_exists('status') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
485 |
status('Exiting child process'); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
486 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
487 |
$remote->destroy(); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
488 |
|
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
489 |
exit(0); |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
490 |
} |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
491 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
492 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
493 |
## STAGE 1: LISTENER AND INIT |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
494 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
495 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
496 |
// wait for connection... |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
497 |
if ( !$this->threader->is_child() ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
498 |
{ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
499 |
$remote = $this->server->accept(); |
12
b3fcc21e557f
Backend improvement to webserver that causes interrupts to work properly; made pcntl_signal only be called if it's supported
Dan
parents:
10
diff
changeset
|
500 |
} |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
501 |
|
12
b3fcc21e557f
Backend improvement to webserver that causes interrupts to work properly; made pcntl_signal only be called if it's supported
Dan
parents:
10
diff
changeset
|
502 |
if ( !$remote ) |
b3fcc21e557f
Backend improvement to webserver that causes interrupts to work properly; made pcntl_signal only be called if it's supported
Dan
parents:
10
diff
changeset
|
503 |
{ |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
504 |
$this->in_keepalive = false; |
12
b3fcc21e557f
Backend improvement to webserver that causes interrupts to work properly; made pcntl_signal only be called if it's supported
Dan
parents:
10
diff
changeset
|
505 |
continue; |
b3fcc21e557f
Backend improvement to webserver that causes interrupts to work properly; made pcntl_signal only be called if it's supported
Dan
parents:
10
diff
changeset
|
506 |
} |
b3fcc21e557f
Backend improvement to webserver that causes interrupts to work properly; made pcntl_signal only be called if it's supported
Dan
parents:
10
diff
changeset
|
507 |
|
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
508 |
// fork off if possible |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
509 |
if ( function_exists('pcntl_fork') && $this->allow_fork && !$this->in_keepalive ) |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
510 |
{ |
53 | 511 |
if ( $this->threader->fork() == Threader::FORK_CHILD ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
512 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
513 |
// this is the child |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
514 |
define('HTTPD_WS_CHILD', 1); |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
515 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
516 |
else |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
517 |
{ |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
518 |
// we are the parent, continue listening |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
519 |
$remote->soft_shutdown(); |
32
86140ed9087d
Experimental: upon change to playlist, send SIGUSR1 to parent process and branch out to all children to force a playlist refresh
Dan
parents:
26
diff
changeset
|
520 |
$this->child_list[] = $pid; |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
521 |
continue; |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
522 |
} |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
523 |
} |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
524 |
|
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
525 |
$this->in_keepalive = false; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
526 |
$this->headers_sent = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
527 |
$this->in_scriptlet = false; |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
528 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
529 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
530 |
## STAGE 2: READ REQUEST |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
531 |
## |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
532 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
533 |
// this is a complicated situation because we need to keep enough ticks going to properly handle |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
534 |
// signals, meaning we can't use stream_set_timeout() and instead need to rely on our own timing |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
535 |
// logic. setting the timeout to a short period, say 200,000 usec, we can minimize CPU usage and |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
536 |
// have a good response time. |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
537 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
538 |
$remote->set_timeout(0, 200000); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
539 |
$start_time = microtime(true); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
540 |
$client_headers = ''; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
541 |
$last_line = ''; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
542 |
while ( true ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
543 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
544 |
if ( $start_time + HTTPD_KEEP_ALIVE_TIMEOUT < microtime(true) || $remote->is_eof() ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
545 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
546 |
// request expired -- end the process here |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
547 |
if ( !$this->threader->is_child() ) |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
548 |
$remote->destroy(); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
549 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
550 |
continue 2; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
551 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
552 |
$line = strval($remote->read_normal()); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
553 |
$line = str_replace("\r", "", $line); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
554 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
555 |
// raw layer wants to send 2 empty lines through, stream layer wants to send one. |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
556 |
$last_line_check = ( HTTPD_SOCKET_LAYER != 'Raw' || ( HTTPD_SOCKET_LAYER == 'Raw' && $last_line == "\n" ) ); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
557 |
if ( $line == "\n" && $last_line_check ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
558 |
// we have two newlines in a row, break out since we have a full request |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
559 |
break; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
560 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
561 |
$client_headers .= $line; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
562 |
$last_line = $line; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
563 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
564 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
565 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
566 |
## STAGE 3: PARSE REQUEST AND HEADERS |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
567 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
568 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
569 |
// parse request |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
570 |
$client_headers = trim($client_headers); |
29 | 571 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
572 |
if ( isset($last_finish_time) && empty($client_headers) && $this->threader->is_child() && $last_finish_time + HTTPD_KEEP_ALIVE_TIMEOUT < microtime(true) ) |
29 | 573 |
{ |
574 |
status('[debug] keep-alive connection timed out (checkpoint 2)'); |
|
575 |
continue; // will jump back to the start of the loop and kill the child process |
|
576 |
} |
|
577 |
||
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
578 |
$client_headers = explode("\n", $client_headers); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
579 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
580 |
// first line |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
581 |
$request = $client_headers[0]; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
582 |
if ( !preg_match('/^(GET|POST) \/([^ ]*) HTTP\/1\.[01]$/', $request, $match) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
583 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
584 |
$this->send_http_error($remote, 400, 'Your client issued a malformed or illegal request.'); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
585 |
continue; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
586 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
587 |
$method =& $match[1]; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
588 |
$uri =& $match[2]; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
589 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
590 |
// set client header SERVER variables |
43 | 591 |
foreach ( $_SERVER as $key => $_ ) |
592 |
{ |
|
593 |
if ( preg_match('/^HTTP_/', $key) ) |
|
594 |
unset($_SERVER[$key]); |
|
595 |
} |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
596 |
unset($client_headers[0]); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
597 |
foreach ( $client_headers as $line ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
598 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
599 |
if ( !preg_match('/^([A-z0-9-]+): (.+)$/is', $line, $match) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
600 |
continue; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
601 |
$key = 'HTTP_' . strtoupper(str_replace('-', '_', $match[1])); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
602 |
$_SERVER[$key] = $match[2]; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
603 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
604 |
|
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
605 |
// enable keep-alive if requested |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
606 |
if ( isset($_SERVER['HTTP_CONNECTION']) && $this->threader->is_child() ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
607 |
{ |
16
23d4cf2f183b
Disabled forking/keep-alive code, firefox doesn't seem to like the way it waits for requests
Dan
parents:
15
diff
changeset
|
608 |
$this->in_keepalive = ( strtolower($_SERVER['HTTP_CONNECTION']) === 'keep-alive' ); |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
609 |
} |
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
610 |
|
43 | 611 |
// process cookies |
612 |
$_COOKIE = array(); |
|
613 |
if ( isset($_SERVER['HTTP_COOKIE']) ) |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
614 |
{ |
43 | 615 |
preg_match_all('/([a-z0-9_-]+)=([^;]*)(?:;|$)/', trim($_SERVER['HTTP_COOKIE']), $matches); |
616 |
foreach ( $matches[0] as $i => $match ) |
|
617 |
{ |
|
618 |
$_COOKIE[$matches[1][$i]] = str_replace('\\r', "\r", str_replace('\\n', "\n", str_replace(rawurlencode(';'), ';', $matches[2][$i]))); |
|
619 |
} |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
620 |
} |
43 | 621 |
|
622 |
// parse authorization, if any |
|
623 |
unset($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']); |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
624 |
if ( isset($_SERVER['HTTP_AUTHORIZATION']) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
625 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
626 |
$data = $_SERVER['HTTP_AUTHORIZATION']; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
627 |
$data = substr(strstr($data, ' '), 1); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
628 |
$data = base64_decode($data); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
629 |
$_SERVER['PHP_AUTH_USER'] = substr($data, 0, strpos($data, ':')); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
630 |
$_SERVER['PHP_AUTH_PW'] = substr(strstr($data, ':'), 1); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
631 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
632 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
633 |
// anything on POST? |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
634 |
$postdata = ''; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
635 |
$_POST = array(); |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
636 |
$_FILES = array(); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
637 |
if ( $method == 'POST' ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
638 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
639 |
$this->parse_post_data($remote); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
640 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
641 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
642 |
// parse URI |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
643 |
$params = ''; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
644 |
if ( strstr($uri, '?') ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
645 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
646 |
$params = substr(strstr($uri, '?'), 1); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
647 |
$uri = substr($uri, 0, strpos($uri, '?')); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
648 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
649 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
650 |
// set some server vars |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
651 |
$_SERVER['REQUEST_URI'] = '/' . rawurldecode($uri); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
652 |
$_SERVER['REQUEST_METHOD'] = $method; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
653 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
654 |
// get remote IP and port |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
655 |
$remote->get_peer_info($_SERVER['REMOTE_ADDR'], $_SERVER['REMOTE_PORT']); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
656 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
657 |
// process $_GET |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
658 |
$_GET = array(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
659 |
if ( preg_match_all('/(^|&)([a-z0-9_\.\[\]-]+)(=[^ &]+)?/', $params, $matches) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
660 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
661 |
if ( isset($matches[1]) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
662 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
663 |
foreach ( $matches[0] as $i => $_ ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
664 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
665 |
$_GET[$matches[2][$i]] = ( !empty($matches[3][$i]) ) ? urldecode(substr($matches[3][$i], 1)) : true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
666 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
667 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
668 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
669 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
670 |
// Parse GET, POST, and FILES into multi-depth arrays |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
671 |
$_GET = $this->parse_multi_depth_array($_GET); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
672 |
$_POST = $this->parse_multi_depth_array($_POST); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
673 |
$_FILES = $this->parse_multi_depth_array($_FILES); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
674 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
675 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
676 |
## STAGE 4: HANDLER RESOLUTION |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
677 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
678 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
679 |
// init handler |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
680 |
$handler = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
681 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
682 |
if ( $uri == '' ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
683 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
684 |
// user requested the root (/). If there's a default document, use that; else, see if we can do a directory listing |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
685 |
$uri = strval($this->default_document); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
686 |
if ( !$this->default_document && $this->allow_dir_list ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
687 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
688 |
// we can list directories and this was requested by the user, so list it out |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
689 |
$handler = array('type' => 'rootdir'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
690 |
} |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
691 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
692 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
693 |
$uri_parts = explode('/', $uri); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
694 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
695 |
// hook for the special UUID handler |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
696 |
if ( $uri_parts[0] === $this->uuid && !$handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
697 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
698 |
$handler = array('type' => 'sysuuid'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
699 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
700 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
701 |
// loop through URI parts, see if a handler is set |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
702 |
if ( !$handler ) |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
703 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
704 |
for ( $i = count($uri_parts) - 1; $i >= 0; $i-- ) |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
705 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
706 |
$handler_test = implode('/', $uri_parts); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
707 |
if ( isset($this->handlers[$handler_test]) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
708 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
709 |
$handler = $this->handlers[$handler_test]; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
710 |
$handler['id'] = $handler_test; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
711 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
712 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
713 |
unset($uri_parts[$i]); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
714 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
715 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
716 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
717 |
if ( !$handler ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
718 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
719 |
// try to make a fakie |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
720 |
if ( $this->check_for_handler_children($uri) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
721 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
722 |
$handler = array( |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
723 |
'type' => 'folder', |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
724 |
'dir' => "/{$this->uuid}/__fakie", |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
725 |
'id' => $uri |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
726 |
); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
727 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
728 |
if ( !$handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
729 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
730 |
$this->send_http_error($remote, 404, "The requested URL /$uri was not found on this server."); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
731 |
continue; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
732 |
} |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
733 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
734 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
735 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
736 |
## STAGE 5: HANDLER CALL |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
737 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
738 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
739 |
$this->send_standard_response($remote, $handler, $uri, $params); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
740 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
741 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
742 |
## STAGE 6: CLEANUP |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
743 |
## |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
744 |
|
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
745 |
// now that we're done sending the response, delete any temporary uploaded files |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
746 |
if ( !empty($_FILES) ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
747 |
{ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
748 |
foreach ( $_FILES as $file_data ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
749 |
{ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
750 |
if ( file_exists($file_data['tmp_name']) ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
751 |
{ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
752 |
@unlink($file_data['tmp_name']); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
753 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
754 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
755 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
756 |
|
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
757 |
if ( !$this->in_keepalive && $this->threader->is_child() ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
758 |
{ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
759 |
// connection: close |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
760 |
// continue on to the shutdown handler |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
761 |
continue; |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
762 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
763 |
else if ( $this->threader->is_child() ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
764 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
765 |
// if ( $this->threader->is_child() ) |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
766 |
// status('Continuing connection'); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
767 |
// $remote->write("\r\n\r\n"); |
29 | 768 |
$last_finish_time = microtime(true); |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
769 |
} |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
770 |
else |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
771 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
772 |
// standalone process |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
773 |
$remote->destroy(); |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
774 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
775 |
// if a reboot was fired and we're running in single-process mode, now is the time to respawn |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
776 |
if ( !$this->threader->is_child() && $this->reboot_sent ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
777 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
778 |
$this->respawn(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
779 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
780 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
781 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
782 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
783 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
784 |
/** |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
785 |
* Parse POST data and format $_POST and $_FILES. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
786 |
* @param resource Remote socket |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
787 |
*/ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
788 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
789 |
function parse_post_data($remote) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
790 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
791 |
$postdata = ''; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
792 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
793 |
// read POST data |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
794 |
if ( isset($_SERVER['HTTP_CONTENT_TYPE']) && preg_match('#^multipart/form-data; ?boundary=([A-z0-9_-]+)$#i', $_SERVER['HTTP_CONTENT_TYPE'], $match) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
795 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
796 |
// this is a multipart request |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
797 |
$boundary =& $match[1]; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
798 |
$mode = 'data'; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
799 |
$last_line = ''; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
800 |
$i = 0; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
801 |
while ( $data = $remote->read_normal(8388608) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
802 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
803 |
$data_trim = trim($data, "\r\n"); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
804 |
if ( $mode != 'data' ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
805 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
806 |
$data = str_replace("\r", '', $data); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
807 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
808 |
if ( ( $data_trim === "--$boundary" || $data_trim === "--$boundary--" ) && $i > 0 ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
809 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
810 |
// trim off the first LF and the last CRLF |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
811 |
if ( HTTPD_SOCKET_LAYER == 'Raw' ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
812 |
$currval_data = substr($currval_data, 1, strlen($currval_data)-3); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
813 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
814 |
$currval_data = substr($currval_data, 0, strlen($currval_data)-2); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
815 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
816 |
// this is the end of a part of the message; parse it into either $_POST or $_FILES |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
817 |
if ( is_string($have_a_file) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
818 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
819 |
// write data to a temporary file |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
820 |
$errcode = UPLOAD_ERR_OK; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
821 |
$tempfile = tempnam('phpupload', ( function_exists('sys_get_temp_dir') ? sys_get_temp_dir() : '/tmp' )); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
822 |
if ( $fh = @fopen($tempfile, 'w') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
823 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
824 |
if ( empty($have_a_file) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
825 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
826 |
$errcode = UPLOAD_ERR_NO_FILE; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
827 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
828 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
829 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
830 |
fwrite($fh, $currval_data); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
831 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
832 |
fclose($fh); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
833 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
834 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
835 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
836 |
$errcode = UPLOAD_ERR_CANT_WRITE; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
837 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
838 |
$_FILES[$currval_name] = array( |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
839 |
'name' => $have_a_file, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
840 |
'type' => $currval_type, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
841 |
'size' => filesize($tempfile), |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
842 |
'tmp_name' => $tempfile, |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
843 |
'error' => $errcode |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
844 |
); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
845 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
846 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
847 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
848 |
if ( preg_match('/\[\]$/', $currval_name) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
849 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
850 |
if ( !isset($_POST[$currval_name]) || ( isset($_POST[$currval_name]) && !is_array($_POST[$currval_name]) ) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
851 |
$_POST[$currval_name] = array(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
852 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
853 |
$_POST[$currval_name][] = $currval_data; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
854 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
855 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
856 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
857 |
$_POST[$currval_name] = $currval_data; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
858 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
859 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
860 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
861 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
862 |
if ( $data_trim === "--$boundary" ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
863 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
864 |
// switch from "data" mode to "headers" mode |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
865 |
$currval_name = ''; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
866 |
$currval_data = ''; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
867 |
$currval_type = ''; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
868 |
$have_a_file = false; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
869 |
$mode = 'headers'; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
870 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
871 |
else if ( $data_trim === "--$boundary--" ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
872 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
873 |
// end of request |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
874 |
break; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
875 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
876 |
else if ( ( empty($data_trim) && ( ( HTTPD_SOCKET_LAYER == 'Raw' && empty($last_line) ) || HTTPD_SOCKET_LAYER != 'Raw' ) ) && $mode == 'headers' ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
877 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
878 |
// start of data |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
879 |
$mode = 'data'; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
880 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
881 |
else if ( $mode == 'headers' ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
882 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
883 |
// read header |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
884 |
// we're only looking for Content-Disposition and Content-Type |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
885 |
if ( preg_match('#^Content-Disposition: form-data; name="([^"\a\t\r\n]+)"(?:; filename="([^"\a\t\r\n]+)")?#i', $data_trim, $match) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
886 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
887 |
// content-disposition header, set name and mode. |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
888 |
$currval_name = $match[1]; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
889 |
if ( isset($match[2]) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
890 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
891 |
$have_a_file = $match[2]; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
892 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
893 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
894 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
895 |
$have_a_file = false; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
896 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
897 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
898 |
else if ( preg_match('#^Content-Type: ([a-z0-9-]+/[a-z0-9/-]+)$#i', $data_trim, $match) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
899 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
900 |
$currval_type = $match[1]; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
901 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
902 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
903 |
else if ( $mode == 'data' ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
904 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
905 |
$currval_data .= $data; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
906 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
907 |
$last_line = $data_trim; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
908 |
$i++; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
909 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
910 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
911 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
912 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
913 |
if ( isset($_SERVER['HTTP_CONTENT_LENGTH']) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
914 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
915 |
$postdata = $remote->read_binary(intval($_SERVER['HTTP_CONTENT_LENGTH'])); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
916 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
917 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
918 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
919 |
$postdata = $remote->read_normal(8388608); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
920 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
921 |
if ( preg_match_all('/(^|&)([a-z0-9_\.\[\]%-]+)(=[^ &]+)?/i', $postdata, $matches) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
922 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
923 |
if ( isset($matches[1]) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
924 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
925 |
foreach ( $matches[0] as $i => $_ ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
926 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
927 |
$currval_name =& $matches[2][$i]; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
928 |
$currval_data = ( !empty($matches[3][$i]) ) ? urldecode(substr($matches[3][$i], 1)) : true; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
929 |
$currval_name = urldecode($currval_name); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
930 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
931 |
if ( preg_match('/\[\]$/', $currval_name) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
932 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
933 |
$basename = preg_replace('/\[\]$/', '', $currval_name); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
934 |
if ( !isset($_POST[$basename]) || ( isset($_POST[$basename]) && !is_array($_POST[$basename]) ) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
935 |
$_POST[$basename] = array(); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
936 |
|
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
937 |
$_POST[$basename][] = $currval_data; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
938 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
939 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
940 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
941 |
$_POST[$currval_name] = $currval_data; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
942 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
943 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
944 |
} |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
945 |
} |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
946 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
947 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
948 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
949 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
950 |
* Sends the client appropriate response headers. |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
951 |
* @param resource Socket connection to client |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
952 |
* @param int HTTP status code, defaults to 200 |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
953 |
* @param string Content type, defaults to text/html |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
954 |
* @param string Additional headers to send, optional |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
955 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
956 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
957 |
function send_client_headers($socket, $http_code = 200, $contenttype = 'text/html', $headers = '') |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
958 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
959 |
global $http_responses; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
960 |
if ( $this->headers_sent ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
961 |
return false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
962 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
963 |
// this is reset after the request is completed (hopefully) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
964 |
$this->headers_sent = true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
965 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
966 |
$reason_code = ( isset($http_responses[$http_code]) ) ? $http_responses[$http_code] : 'Unknown'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
967 |
|
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
968 |
$_SERVER['HTTP_USER_AGENT'] = ( isset($_SERVER['HTTP_USER_AGENT']) ) ? $_SERVER['HTTP_USER_AGENT'] : '(no user agent)'; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
969 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
970 |
if ( function_exists('status') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
971 |
status("{$_SERVER['REMOTE_ADDR']} {$_SERVER['REQUEST_METHOD']} {$_SERVER['REQUEST_URI']} $http_code {$_SERVER['HTTP_USER_AGENT']}"); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
972 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
973 |
$headers = str_replace("\r\n", "\n", $headers); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
974 |
$headers = str_replace("\n", "\r\n", $headers); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
975 |
$headers = preg_replace("#[\r\n]+$#", '', $headers); |
15
2adca0f363fd
Added multi-threading/forking/keep-alive support to webserver. w00t, feeling all POSIX-happy today!
Dan
parents:
13
diff
changeset
|
976 |
$connection = ( $this->in_keepalive ) ? 'keep-alive' : 'close'; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
977 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
978 |
$socket->write("HTTP/1.1 $http_code $reason_code\r\n"); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
979 |
$socket->write("Server: $this->server_string"); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
980 |
$socket->write("Connection: $connection\r\n"); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
981 |
$socket->write("Content-Type: $contenttype\r\n"); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
982 |
if ( !empty($headers) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
983 |
{ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
984 |
$socket->write("$headers\r\n"); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
985 |
} |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
986 |
$socket->write("\r\n"); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
987 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
988 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
989 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
990 |
* Sends a normal response |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
991 |
* @param resource Socket connection to client |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
992 |
* @param array Handler |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
993 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
994 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
995 |
function send_standard_response($socket, $handler) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
996 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
997 |
switch ( $handler['type'] ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
998 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
999 |
case 'folder': |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1000 |
// security |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1001 |
$uri = str_replace("\000", '', $_SERVER['REQUEST_URI']); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1002 |
if ( preg_match('#(\.\./|\/\.\.)#', $uri) || strstr($uri, "\r") || strstr($uri, "\n") ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1003 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1004 |
$this->send_http_error($socket, 403, 'Access to this resource is forbidden.'); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1005 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1006 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1007 |
// import mimetypes |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1008 |
global $mime_types; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1009 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1010 |
// trim handler id from uri |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1011 |
$uri_full = rtrim($uri, '/'); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1012 |
$uri = substr($uri, strlen($handler['id']) + 1); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1013 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1014 |
// get file path |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1015 |
$file_path = rtrim($handler['dir'], '/') . $uri; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1016 |
if ( file_exists($file_path) || $this->check_for_handler_children($uri_full) ) |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1017 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1018 |
// found it :-D |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1019 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1020 |
// is this a directory? |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1021 |
if ( is_dir($file_path) || $this->check_for_handler_children($uri_full) ) |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1022 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1023 |
// allowed to list? |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1024 |
if ( !$this->allow_dir_list ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1025 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1026 |
$this->send_http_error($socket, 403, "Directory listing is not allowed."); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1027 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1028 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1029 |
// yes, list contents |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1030 |
try |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1031 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1032 |
$dir_list = $this->list_directory($uri_full, true); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1033 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1034 |
catch ( Exception $e ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1035 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1036 |
$this->send_http_error($socket, 500, "Directory listing failed due to an error in the listing core method. This may indicate that the webserver process does not have filesystem access to the specified directory.<br /><br />Debugging details:<pre>$e</pre>"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1037 |
return true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1038 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1039 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1040 |
$root = rtrim($uri_full, '/') . '/'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1041 |
$parent = rtrim(dirname(rtrim($uri_full, '/')), '/') . '/'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1042 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1043 |
$contents = <<<EOF |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1044 |
<html> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1045 |
<head> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1046 |
<title>Index of: $root</title> |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1047 |
<link rel="stylesheet" type="text/css" href="/{$this->uuid}/dirlist.css" /> |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1048 |
</head> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1049 |
<body> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1050 |
<h1>Index of $root</h1> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1051 |
<ul> |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1052 |
<li><tt><a href="$parent">Parent directory</a></tt></li> |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1053 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1054 |
EOF; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1055 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1056 |
foreach ( $dir_list as $filename => $info ) |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1057 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1058 |
$ts = ( $info['type'] == 'folder' ) ? '/' : ''; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1059 |
$contents .= ' <li><tt><a href="' . htmlspecialchars($root . basename($filename) . $ts) . '"><img alt="[ ]" src="/' . $this->uuid . '/' . $info['type'] . '.png" /> ' . htmlspecialchars($filename) . $ts . '</a></tt></li>' . "\n "; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1060 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1061 |
$contents .= "\n </ul>\n <address>Served by {$this->server_string}</address>\n</body>\n</html>\n\n"; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1062 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1063 |
$sz = strlen($contents); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1064 |
$this->send_client_headers($socket, 200, 'text/html', "Content-length: $sz\r\n"); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1065 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1066 |
$socket->write($contents); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1067 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1068 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1069 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1070 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1071 |
// try to open the file |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1072 |
$fh = @fopen($file_path, 'r'); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1073 |
if ( !$fh ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1074 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1075 |
// can't open it, send a 404 |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1076 |
$this->send_http_error($socket, 404, "The requested URL " . htmlspecialchars($_SERVER['REQUEST_URI']) . " was not found on this server."); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1077 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1078 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1079 |
// get size |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1080 |
$sz = filesize($file_path); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1081 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1082 |
// mod time |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1083 |
$time = date('r', filemtime($file_path)); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1084 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1085 |
// all good, send headers |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1086 |
$fileext = substr($file_path, strrpos($file_path, '.') + 1); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1087 |
$mimetype = ( isset($mime_types[$fileext]) ) ? $mime_types[$fileext] : 'application/octet-stream'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1088 |
$this->send_client_headers($socket, 200, $mimetype, "Content-length: $sz\r\nLast-Modified: $time\r\n"); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1089 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1090 |
// send body |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1091 |
while ( $blk = @fread($fh, 768000) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1092 |
{ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1093 |
$socket->write($blk); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1094 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1095 |
fclose($fh); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1096 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1097 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1098 |
else |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1099 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1100 |
$this->send_http_error($socket, 404, "The requested URL " . htmlspecialchars($_SERVER['REQUEST_URI']) . " was not found on this server."); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1101 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1102 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1103 |
break; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1104 |
case 'file': |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1105 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1106 |
// import mimetypes |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1107 |
global $mime_types; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1108 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1109 |
// get file path |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1110 |
$file_path = $handler['file']; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1111 |
if ( file_exists($file_path) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1112 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1113 |
// found it :-D |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1114 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1115 |
// is this a directory? |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1116 |
if ( is_dir($file_path) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1117 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1118 |
$this->send_http_error($socket, 500, "Host script mapped a directory as a file entry."); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1119 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1120 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1121 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1122 |
// try to open the file |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1123 |
$fh = @fopen($file_path, 'r'); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1124 |
if ( !$fh ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1125 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1126 |
// can't open it, send a 404 |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1127 |
$this->send_http_error($socket, 404, "The requested URL " . htmlspecialchars($_SERVER['REQUEST_URI']) . " was not found on this server."); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1128 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1129 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1130 |
// get size |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1131 |
$sz = filesize($file_path); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1132 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1133 |
// mod time |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1134 |
$time = date('r', filemtime($file_path)); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1135 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1136 |
// all good, send headers |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1137 |
$fileext = substr($file_path, strrpos($file_path, '.') + 1); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1138 |
$mimetype = ( isset($mime_types[$fileext]) ) ? $mime_types[$fileext] : 'application/octet-stream'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1139 |
$this->send_client_headers($socket, 200, $mimetype, "Content-length: $sz\r\nLast-Modified: $time\r\n"); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1140 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1141 |
// send body |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1142 |
while ( $blk = @fread($fh, 768000) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1143 |
{ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1144 |
$socket->write($blk); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1145 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1146 |
fclose($fh); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1147 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1148 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1149 |
else |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1150 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1151 |
$this->send_http_error($socket, 404, "The requested URL " . htmlspecialchars($_SERVER['REQUEST_URI']) . " was not found on this server."); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1152 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1153 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1154 |
break; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1155 |
case 'script': |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1156 |
// init vars |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1157 |
$this->content_type = 'text/html'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1158 |
$this->response_code = 200; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1159 |
$this->response_headers = array(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1160 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1161 |
// error handling |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1162 |
@set_error_handler(array($this, 'function_error_handler'), E_ALL); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1163 |
try |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1164 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1165 |
ob_start(); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1166 |
$this->in_scriptlet = true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1167 |
$result = @call_user_func($handler['function'], $this, $socket); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1168 |
$this->in_scriptlet = false; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1169 |
$output = ob_get_contents(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1170 |
ob_end_clean(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1171 |
} |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1172 |
// throw an HttpExceptionFatal when you need to break out of an in-progress scriptlet due to an error, use it in place of die() or exit() |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1173 |
catch ( HttpExceptionFatal $e ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1174 |
{ |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1175 |
ob_end_clean(); |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1176 |
restore_error_handler(); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1177 |
$this->send_http_error($socket, 500, "A handler crashed reporting a fatal exception; see the command line for details."); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1178 |
if ( function_exists('status') ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1179 |
status("fatal exception in handler {$handler['id']}:\n$e"); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1180 |
return true; |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1181 |
} |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1182 |
catch ( HttpSuccess $e ) |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1183 |
{ |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1184 |
// just finish with success |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1185 |
$this->in_scriptlet = false; |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1186 |
$output = ob_get_contents(); |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1187 |
ob_end_clean(); |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1188 |
} |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1189 |
catch ( Exception $e ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1190 |
{ |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1191 |
ob_end_clean(); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1192 |
restore_error_handler(); |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1193 |
$this->send_http_error($socket, 500, "There was an uncaught exception during the execution of a scripted handler function. See the command line for details."); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1194 |
if ( function_exists('status') ) |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1195 |
status("uncaught exception in handler {$handler['id']}:\n$e"); |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1196 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1197 |
} |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
1198 |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1199 |
restore_error_handler(); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1200 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1201 |
// the handler function should return this magic string if it writes its own headers and socket data |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1202 |
if ( $output == '__break__' ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1203 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1204 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1205 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1206 |
|
40
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1207 |
if ( !$this->headers_sent ) |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1208 |
{ |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1209 |
// $this->header('Transfer-encoding: chunked'); |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1210 |
$this->header("Content-length: " . strlen($output)); |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1211 |
$headers = implode("\r\n", $this->response_headers); |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1212 |
|
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1213 |
// write headers |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1214 |
$this->send_client_headers($socket, $this->response_code, $this->content_type, $headers); |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1215 |
|
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1216 |
// chunk output |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1217 |
// $output = dechex(strlen($output)) . "\r\n$output"; |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1218 |
|
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1219 |
// write body |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1220 |
$socket->write($output); |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1221 |
|
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1222 |
$this->headers_sent = false; |
bd3372a2afc1
Added artwork spriting support. Artwork is now displayed using a gigantic CSS sprite instead of hundreds of little images. GD required.
Dan
parents:
38
diff
changeset
|
1223 |
} |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1224 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1225 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1226 |
case 'sysuuid': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1227 |
// requested one of the system's icon images |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1228 |
$uri_parts = explode('/', $_SERVER['REQUEST_URI']); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1229 |
if ( count($uri_parts) != 3 ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1230 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1231 |
$this->send_http_error($socket, 404, "The requested URL " . htmlspecialchars($_SERVER['REQUEST_URI']) . " was not found on this server."); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1232 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1233 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1234 |
// load image data |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1235 |
$filename =& $uri_parts[2]; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1236 |
switch ( $filename ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1237 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1238 |
case 'script.png': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1239 |
( !isset($image_data) ) ? $image_data = HTTPD_ICON_SCRIPT : null; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1240 |
case 'folder.png': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1241 |
( !isset($image_data) ) ? $image_data = HTTPD_ICON_FOLDER : null; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1242 |
case 'file.png': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1243 |
( !isset($image_data) ) ? $image_data = HTTPD_ICON_FILE : null; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1244 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1245 |
$image_data = base64_decode($image_data); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1246 |
$found = true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1247 |
$type = 'image/png'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1248 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1249 |
case 'dirlist.css': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1250 |
$type = 'text/css'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1251 |
$found = true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1252 |
$image_data = <<<EOF |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1253 |
/** |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1254 |
* PhpHttpd directory list visual style |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1255 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1256 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1257 |
html { |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1258 |
background-color: #c9c9c9; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1259 |
margin: 0; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1260 |
padding: 0; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1261 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1262 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1263 |
body { |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1264 |
background-color: #ffffff; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1265 |
margin: 20px; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1266 |
padding: 10px; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1267 |
border: 1px solid #aaaaaa; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1268 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1269 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1270 |
a { |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1271 |
text-decoration: none; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1272 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1273 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1274 |
a img { |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1275 |
border-width: 0; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1276 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1277 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1278 |
ul { |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1279 |
list-style-type: none; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1280 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1281 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1282 |
EOF; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1283 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1284 |
default: |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1285 |
$found = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1286 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1287 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1288 |
// ship it out |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1289 |
if ( $found ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1290 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1291 |
$lm_date = date('r', filemtime(__FILE__)); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1292 |
$size = strlen($image_data); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1293 |
$this->send_client_headers($socket, 200, $type, "Last-Modified: $lm_date\r\nContent-Length: $size"); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1294 |
$socket->write($image_data); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1295 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1296 |
else |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1297 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1298 |
$this->send_http_error($socket, 404, "The requested URL " . htmlspecialchars($_SERVER['REQUEST_URI']) . " was not found on this server."); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1299 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1300 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1301 |
return true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1302 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1303 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1304 |
case 'rootdir': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1305 |
// |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1306 |
// list the contents of the document root |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1307 |
// |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1308 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1309 |
$handlers = $this->list_directory('/', true); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1310 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1311 |
$contents = <<<EOF |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1312 |
<html> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1313 |
<head> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1314 |
<title>Index of: /</title> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1315 |
<link rel="stylesheet" type="text/css" href="/{$this->uuid}/dirlist.css" /> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1316 |
</head> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1317 |
<body> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1318 |
<h1>Index of /</h1> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1319 |
<ul> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1320 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1321 |
EOF; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1322 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1323 |
$html = ''; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1324 |
// generate content |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1325 |
foreach ( $handlers as $uri => $handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1326 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1327 |
switch($handler['type']) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1328 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1329 |
case 'folder': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1330 |
$image = 'folder.png'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1331 |
$abbr = 'DIR'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1332 |
$add = '/'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1333 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1334 |
case 'file': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1335 |
default: |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1336 |
$image = 'file.png'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1337 |
$abbr = ' '; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1338 |
$add = ''; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1339 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1340 |
case 'script': |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1341 |
$image = 'script.png'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1342 |
$abbr = 'CGI'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1343 |
$add = ''; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1344 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1345 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1346 |
$html .= " <li><tt><a href=\"/$uri\"><img alt=\"[{$abbr}]\" src=\"/{$this->uuid}/{$image}\" /> {$uri}{$add}</a></tt></li>\n "; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1347 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1348 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1349 |
$contents .= $html; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1350 |
$contents .= <<<EOF |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1351 |
</ul> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1352 |
<address>Served by {$this->server_string}</address> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1353 |
</body> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1354 |
</html> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1355 |
EOF; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1356 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1357 |
// get length |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1358 |
$len = strlen($contents); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1359 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1360 |
// send headers |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1361 |
$this->send_client_headers($socket, 200, 'text/html', "Content-Length: $len"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1362 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1363 |
// write to the socket |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1364 |
$socket->write($contents); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1365 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1366 |
return true; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1367 |
break; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1368 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1369 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1370 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1371 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1372 |
* Adds an HTTP header value to send back to the client |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1373 |
* @var string Header |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1374 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1375 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1376 |
function header($str) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1377 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1378 |
if ( preg_match('#HTTP/1\.[01] ([0-9]+) (.+?)[\s]*$#', $str, $match) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1379 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1380 |
$this->response_code = intval($match[1]); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1381 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1382 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1383 |
else if ( preg_match('#Content-type: ([^ ;]+)#i', $str, $match) ) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1384 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1385 |
$this->content_type = $match[1]; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1386 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1387 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1388 |
$this->response_headers[] = $str; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1389 |
return true; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1390 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1391 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1392 |
/** |
43 | 1393 |
* Sets a cookie. Identical to PHP's setcookie() function. |
1394 |
* @param string Cookie name |
|
1395 |
* @param string Cookie value |
|
1396 |
* @param int Expiration time of cookie as a UNIX timestamp; if omitted or set to zero, cookie will expire at the end of the user's browser session |
|
1397 |
* @param string Path of the cookie |
|
1398 |
* @param string Domain the cookie is available under |
|
1399 |
* @param bool If true, browser will only send the cookie through an HTTPS connection. |
|
1400 |
* @param bool If true, cookie will not be accessible to client-side code |
|
1401 |
*/ |
|
1402 |
||
1403 |
function setcookie($cookiename, $cookievalue, $expiry = false, $path = false, $domain = false, $secure = false, $httponly = false) |
|
1404 |
{ |
|
1405 |
$header = "Set-Cookie: $cookiename=$cookievalue"; |
|
1406 |
if ( !empty($expiry) ) |
|
1407 |
$header .= "; expires=" . date('D, d-M-Y H:i:s T', $expiry); |
|
1408 |
if ( !empty($path) ) |
|
1409 |
$header .= "; path=$path"; |
|
1410 |
if ( !empty($domain) ) |
|
1411 |
$header .= "; domain=$domain"; |
|
1412 |
if ( $secure ) |
|
1413 |
$header .= "; secure"; |
|
1414 |
if ( $httponly ) |
|
1415 |
$header .= "; httponly"; |
|
1416 |
||
1417 |
if ( is_int($expiry) && $expiry < time() ) |
|
1418 |
{ |
|
1419 |
unset($_COOKIE[$cookiename]); |
|
1420 |
} |
|
1421 |
else |
|
1422 |
{ |
|
1423 |
$_COOKIE[$cookiename] = $cookievalue; |
|
1424 |
} |
|
1425 |
||
1426 |
$this->header($header); |
|
1427 |
} |
|
1428 |
||
1429 |
/** |
|
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1430 |
* Sends the client an HTTP error page |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1431 |
* @param resource Socket connection to client |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1432 |
* @param int HTTP status code |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1433 |
* @param string Detailed error string |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1434 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1435 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1436 |
function send_http_error($socket, $http_code, $errstring) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1437 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1438 |
global $http_responses; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1439 |
$reason_code = ( isset($http_responses[$http_code]) ) ? $http_responses[$http_code] : 'Unknown'; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1440 |
|
26
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1441 |
// generate error page |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1442 |
$html = <<<EOF |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1443 |
<html> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1444 |
<head> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1445 |
<title>$http_code $reason_code</title> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1446 |
</head> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1447 |
<body> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1448 |
<h1>$http_code $reason_code</h1> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1449 |
<p>$errstring</p> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1450 |
<hr /> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1451 |
<address>Served by $this->server_string</address> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1452 |
</body> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1453 |
</html> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1454 |
EOF; |
26
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1455 |
|
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1456 |
// length of the response (required if we want keep-alive to work) |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1457 |
$this->header('Content-length: ' . strlen($html)); |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1458 |
|
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1459 |
// if we're in a scriptlet, include custom headers |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1460 |
if ( $this->in_scriptlet ) |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1461 |
$headers = implode("\r\n", $this->response_headers); |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1462 |
else |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1463 |
$headers = 'Content-length: ' . strlen($html); |
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1464 |
|
300d374d89b0
Made error pages send length of response to get keep-alive working properly; added (nonworking, sorry) keep-alive timeout support.
Dan
parents:
24
diff
changeset
|
1465 |
$this->send_client_headers($socket, $http_code, 'text/html', $headers); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1466 |
$socket->write($html); |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1467 |
} |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1468 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1469 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1470 |
* Adds a new handler |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1471 |
* @param string URI, minus the initial / |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1472 |
* @param string Type of handler - function or dir |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1473 |
* @param string Value - function name or absolute/relative path to directory |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1474 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1475 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1476 |
function add_handler($uri, $type, $value) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1477 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1478 |
if ( $type == 'dir' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1479 |
$type = 'folder'; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1480 |
if ( $type == 'function' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1481 |
$type = 'script'; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1482 |
switch($type) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1483 |
{ |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1484 |
case 'folder': |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1485 |
$this->handlers[$uri] = array( |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1486 |
'type' => 'folder', |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1487 |
'dir' => $value |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1488 |
); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1489 |
break; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1490 |
case 'file': |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1491 |
$this->handlers[$uri] = array( |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1492 |
'type' => 'file', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1493 |
'file' => $value |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1494 |
); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1495 |
break; |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1496 |
case 'script': |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1497 |
$this->handlers[$uri] = array( |
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1498 |
'type' => 'script', |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1499 |
'function' => $value |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1500 |
); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1501 |
break; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1502 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1503 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1504 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1505 |
/** |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1506 |
* Error handling function |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1507 |
* @param see <http://us.php.net/manual/en/function.set-error-handler.php> |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1508 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1509 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1510 |
function function_error_handler($errno, $errstr, $errfile, $errline, $errcontext) |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1511 |
{ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1512 |
echo '<div style="border: 1px solid #AA0000; background-color: #FFF0F0; padding: 10px;">'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1513 |
echo "<b>PHP warning/error:</b> type $errno ($errstr) caught in <b>$errfile</b> on <b>$errline</b><br />"; |
10
d3059e20b0fa
SECURITY: Fix ability to crash server in ajax.php; added playback position slider and ability to seek through current song
Dan
parents:
6
diff
changeset
|
1514 |
// echo "Error context:<pre>" . htmlspecialchars(print_r($errcontext, true)) . "</pre>"; |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1515 |
echo '</div>'; |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1516 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
1517 |
|
21
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1518 |
/** |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1519 |
* Lists out the contents of a directory, including virtual handlers. |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1520 |
* @example |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1521 |
* Example return data: (will be ksorted) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1522 |
<code> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1523 |
array( |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1524 |
'bar' => 'folder', |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1525 |
'baz' => 'script', |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1526 |
'foo' => 'file' |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1527 |
); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1528 |
</code> |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1529 |
* @param string Directory name, relative to the server's document root |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1530 |
* @param bool If true, sorts folders first (default: false) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1531 |
* @return array Exception thrown on failure |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1532 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1533 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1534 |
function list_directory($dir, $folders_first = false) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1535 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1536 |
// clean slashes from the directory name |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1537 |
$dir = trim($dir, '/'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1538 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1539 |
if ( $dir == '' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1540 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1541 |
// |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1542 |
// list the root, which can consist only of handlers |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1543 |
// |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1544 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1545 |
// copy the handlers array, which we need to ksort |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1546 |
$handlers = $this->handlers; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1547 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1548 |
// get rid of multi-depth handlers |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1549 |
foreach ( $handlers as $uri => $handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1550 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1551 |
if ( strpos($uri, '/') ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1552 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1553 |
unset($handlers[$uri]); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1554 |
$newuri = explode('/', $uri); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1555 |
if ( !isset($handlers[$newuri[0]]) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1556 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1557 |
$handlers[$newuri[0]] = array( |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1558 |
'type' => 'folder' |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1559 |
); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1560 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1561 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1562 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1563 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1564 |
ksort($handlers); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1565 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1566 |
if ( $folders_first ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1567 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1568 |
// sort folders first |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1569 |
$handlers_sorted = array(); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1570 |
foreach ( $handlers as $uri => $handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1571 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1572 |
if ( $handler['type'] == 'folder' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1573 |
$handlers_sorted[$uri] = $handler; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1574 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1575 |
foreach ( $handlers as $uri => $handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1576 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1577 |
if ( $handler['type'] != 'folder' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1578 |
$handlers_sorted[$uri] = $handler; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1579 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1580 |
$handlers = $handlers_sorted; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1581 |
unset($handlers_sorted); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1582 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1583 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1584 |
// done |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1585 |
return $handlers; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1586 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1587 |
else |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1588 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1589 |
// list something within the root |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1590 |
$dir_stack = explode('/', $dir); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1591 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1592 |
// lookup handler |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1593 |
$handler_search = $dir; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1594 |
$found_handler = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1595 |
$fake_handler = false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1596 |
$i = 1; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1597 |
while ( $i > 0 ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1598 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1599 |
if ( isset($this->handlers[$handler_search]) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1600 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1601 |
$found_handler = true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1602 |
break; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1603 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1604 |
$i = strrpos($handler_search, '/'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1605 |
$handler_search = substr($handler_search, 0, strrpos($handler_search, '/')); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1606 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1607 |
if ( $this->check_for_handler_children($dir) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1608 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1609 |
$fake_handler = true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1610 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1611 |
else if ( !$found_handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1612 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1613 |
// nope. not there. |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1614 |
throw new Exception("ERR_NO_SUCH_FILE_OR_DIRECTORY"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1615 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1616 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1617 |
// make sure this is a directory |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1618 |
if ( !$fake_handler ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1619 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1620 |
$handler =& $handler_search; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1621 |
if ( $this->handlers[$handler]['type'] != 'folder' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1622 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1623 |
throw new Exception("ERR_NOT_A_DIRECTORY"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1624 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1625 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1626 |
// determine real path |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1627 |
$real_path = realpath($this->handlers[$handler]['dir'] . substr($dir, strlen($handler))); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1628 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1629 |
// directory is resolved; list contents |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1630 |
$dir_contents = array(); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1631 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1632 |
if ( $dr = opendir($real_path) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1633 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1634 |
while ( $dh = readdir($dr) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1635 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1636 |
if ( $dh == '.' || $dh == '..' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1637 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1638 |
continue; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1639 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1640 |
$dir_contents[$dh] = array( |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1641 |
'type' => ( is_dir("$real_path/$dh") ) ? 'folder' : 'file', |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1642 |
'size' => filesize("$real_path/$dh"), |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1643 |
'time' => filemtime("$real_path/$dh") |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1644 |
); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1645 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1646 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1647 |
else |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1648 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1649 |
// only if directory open failed |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1650 |
throw new Exception("ERR_PERMISSION_DENIED"); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1651 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1652 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1653 |
closedir($dr); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1654 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1655 |
// some cleanup |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1656 |
unset($handler, $handler_search); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1657 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1658 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1659 |
// list any additional handlers in there |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1660 |
foreach ( $this->handlers as $handler => $info ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1661 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1662 |
// parse handler name |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1663 |
$handler_name = explode('/', trim($handler, '/')); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1664 |
// is this handler in this directory? |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1665 |
if ( count($handler_name) != count($dir_stack) + 1 ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1666 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1667 |
continue; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1668 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1669 |
foreach ( $dir_stack as $i => $_ ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1670 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1671 |
if ( $dir_stack[$i] != $handler_name[$i] ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1672 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1673 |
continue 2; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1674 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1675 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1676 |
// it's in here! |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1677 |
$dir_contents[ basename($handler) ] = array( |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1678 |
'type' => $info['type'] |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1679 |
); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1680 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1681 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1682 |
// list "fake" handlers |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1683 |
foreach ( $this->handlers as $handler => $info ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1684 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1685 |
// parse handler name |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1686 |
$handler_name = explode('/', trim($handler, '/')); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1687 |
// is this handler somewhere underneath this directory? |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1688 |
if ( count($handler_name) < count($dir_stack) + 2 ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1689 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1690 |
continue; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1691 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1692 |
// path check |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1693 |
foreach ( $dir_stack as $i => $_ ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1694 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1695 |
if ( $dir_stack[$i] != $handler_name[$i] ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1696 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1697 |
continue 2; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1698 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1699 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1700 |
// create a "fake" directory |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1701 |
$fakie_name = $handler_name[ count($dir_stack) ]; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1702 |
$dir_contents[$fakie_name] = array( |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1703 |
'type' => 'folder' |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1704 |
); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1705 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1706 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1707 |
if ( $folders_first ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1708 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1709 |
// perform folder sorting |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1710 |
$unsorted = $dir_contents; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1711 |
ksort($unsorted); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1712 |
$dir_contents = array(); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1713 |
foreach ( $unsorted as $name => $info ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1714 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1715 |
if ( $info['type'] == 'folder' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1716 |
$dir_contents[$name] = $info; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1717 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1718 |
foreach ( $unsorted as $name => $info ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1719 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1720 |
if ( $info['type'] != 'folder' ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1721 |
$dir_contents[$name] = $info; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1722 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1723 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1724 |
else |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1725 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1726 |
// not sorting with folders first, so just alphabetize |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1727 |
ksort($dir_contents); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1728 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1729 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1730 |
// done |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1731 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1732 |
return $dir_contents; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1733 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1734 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1735 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1736 |
/** |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1737 |
* Searches deeper to see if there are sub-handlers within a path to see if a fake handler can be created |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1738 |
* @param string URI |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1739 |
* @return bool |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1740 |
*/ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1741 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1742 |
function check_for_handler_children($file_path) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1743 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1744 |
$file_path = trim($file_path, '/'); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1745 |
$dir_stack = explode('/', $file_path); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1746 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1747 |
// make sure this isn't a "real" handler |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1748 |
if ( isset($this->handlers[$file_path]) ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1749 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1750 |
return false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1751 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1752 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1753 |
// list any additional handlers in there |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1754 |
foreach ( $this->handlers as $handler => $info ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1755 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1756 |
// parse handler name |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1757 |
$handler_name = explode('/', trim($handler, '/')); |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1758 |
// is this handler in this directory? |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1759 |
if ( count($handler_name) != count($dir_stack) + 1 ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1760 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1761 |
continue; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1762 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1763 |
foreach ( $dir_stack as $i => $_ ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1764 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1765 |
if ( $dir_stack[$i] != $handler_name[$i] ) |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1766 |
{ |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1767 |
continue 2; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1768 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1769 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1770 |
// it's in here! |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1771 |
return true; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1772 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1773 |
|
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1774 |
return false; |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1775 |
} |
74edc873234f
Made the webserver a bit smarter. It handles running as root properly (only allows it if user/group specified and port < 1024) and directory listing is massively smarter.
Dan
parents:
17
diff
changeset
|
1776 |
|
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1777 |
/** |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1778 |
* Takes a flat array with keys of format foo[bar] and parses it into multiple depths. |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1779 |
* @param array |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1780 |
* @return array |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1781 |
*/ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1782 |
|
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1783 |
function parse_multi_depth_array($array) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1784 |
{ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1785 |
foreach ( $array as $key => $value ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1786 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1787 |
if ( preg_match('/^([^\[\]]+)\[([^\]]*)\]/', $key, $match) ) |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1788 |
{ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1789 |
$parent =& $match[1]; |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1790 |
$child =& $match[2]; |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1791 |
if ( !isset($array[$parent]) || ( isset($array[$parent]) && !is_array($array[$parent]) ) ) |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1792 |
{ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1793 |
$array[$parent] = array(); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1794 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1795 |
if ( empty($child) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1796 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1797 |
$array[$parent][] = $value; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1798 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1799 |
else |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1800 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1801 |
$array[$parent][$child] = $value; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1802 |
} |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1803 |
unset($array[$key]); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1804 |
$array[$parent] = $this->parse_multi_depth_array($array[$parent]); |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1805 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1806 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1807 |
return $array; |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1808 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
1809 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1810 |
/** |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1811 |
* Handle an IPC event. Called only upon SIGUSR2. |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1812 |
*/ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1813 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1814 |
function _ipc_event() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1815 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1816 |
/* |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1817 |
case 'set_addr': |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1818 |
$this->bind_address = $param; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1819 |
break; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1820 |
case 'set_port': |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1821 |
$this->port = intval($param); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1822 |
break; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1823 |
case 'set_fork': |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1824 |
$this->allow_fork = ( $param == '1' ); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1825 |
break; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1826 |
case 'reboot': |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1827 |
if ( !$this->threader->is_child() ) |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1828 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1829 |
list(, $addr, $port, $fork) = explode(' ', $line); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1830 |
$fork = ( $fork === '1' ); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1831 |
$this->reboot($addr, intval($port), $fork); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1832 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1833 |
break; |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1834 |
default: |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1835 |
if ( isset($this->ipc_handlers[$action]) ) |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1836 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1837 |
@call_user_func($this->ipc_handlers[$action], $line); |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1838 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1839 |
break; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1840 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1841 |
*/ |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1842 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1843 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1844 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1845 |
/** |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1846 |
* Socket abstraction layer - low-level socket functions (socket_*) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1847 |
*/ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1848 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1849 |
class Socket_Raw |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1850 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1851 |
var $sock; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1852 |
var $socket_initted = false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1853 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1854 |
function tcp_listen($address, $port) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1855 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1856 |
// do we have socket functions? |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1857 |
if ( !function_exists('socket_create') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1858 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1859 |
burnout('System does not support socket functions. Please rebuild your PHP or install an appropriate extension.'); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1860 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1861 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1862 |
$this->sock = @socket_create(AF_INET, SOCK_STREAM, getprotobyname('tcp')); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1863 |
if ( !$this->sock ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1864 |
throw new Exception('Could not create socket'); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1865 |
$result = @socket_bind($this->sock, $address, $port); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1866 |
if ( !$result ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1867 |
throw new Exception("Could not bind to $address:$port"); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1868 |
$this->socket_initted = true; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1869 |
$result = @socket_listen($this->sock, SOMAXCONN); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1870 |
if ( !$result ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1871 |
throw new Exception("Could not listen for connections $address:$port"); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1872 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1873 |
$this->socket_initted = true; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1874 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1875 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1876 |
function destroy() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1877 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1878 |
if ( $this->socket_initted ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1879 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1880 |
// http://us3.php.net/manual/en/function.socket-bind.php |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1881 |
if ( !@socket_set_option($this->sock, SOL_SOCKET, SO_REUSEADDR, 1) ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1882 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1883 |
echo socket_strerror(socket_last_error($this->sock)) . "\n"; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1884 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1885 |
@socket_shutdown($this->sock, 2); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1886 |
@socket_close($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1887 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1888 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1889 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1890 |
function accept() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1891 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1892 |
$remote = false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1893 |
$timeout = 5; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1894 |
switch(@socket_select($r = array($this->sock), $w = array($this->sock), $e = array($this->sock), $timeout)) { |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1895 |
case 2: |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1896 |
return false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1897 |
case 1: |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1898 |
$remote = @socket_accept($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1899 |
$return = new Socket_Raw(); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1900 |
$return->sock = $remote; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1901 |
$return->socket_initted = true; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1902 |
return $return; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1903 |
break; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1904 |
case 0: |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1905 |
return false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1906 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1907 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1908 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1909 |
/** |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1910 |
* Closes the socket but doesn't destroy it. |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1911 |
*/ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1912 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1913 |
function soft_shutdown() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1914 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1915 |
@socket_set_option($this->sock, SOL_SOCKET, SO_REUSEADDR, 1); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1916 |
socket_close($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1917 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1918 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1919 |
function set_timeout($timeout, $usec = false) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1920 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1921 |
// doesn't work in this. |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1922 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1923 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1924 |
function read_normal($length = 1024) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1925 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1926 |
return @socket_read($this->sock, $length, PHP_NORMAL_READ); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1927 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1928 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1929 |
function read_binary($length = 1024) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1930 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1931 |
return @socket_read($this->sock, $length, PHP_BINARY_READ); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1932 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1933 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1934 |
function timed_out() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1935 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1936 |
$md = @socket_get_status($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1937 |
return ( isset($md['timed_out']) ) ? $md['timed_out'] : false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1938 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1939 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1940 |
function get_peer_info(&$addr, &$port) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1941 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1942 |
socket_getpeername($this->sock, $addr, $port); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1943 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1944 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1945 |
function write($data) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1946 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1947 |
return @socket_write($this->sock, $data); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1948 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1949 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1950 |
function is_eof() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1951 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1952 |
// feof() not supported |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1953 |
return false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1954 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1955 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1956 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1957 |
/** |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1958 |
* Socket abstraction layer - PHP stream support |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1959 |
*/ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1960 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1961 |
class Socket_Stream |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1962 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1963 |
var $sock; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1964 |
var $socket_initted = false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1965 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1966 |
function tcp_listen($address, $port) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1967 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1968 |
// does PHP support this? |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1969 |
if ( !function_exists('stream_socket_server') ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1970 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1971 |
burnout('System does not support stream functions. Please rebuild your PHP or install an appropriate extension.'); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1972 |
} |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1973 |
|
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1974 |
$this->sock = @stream_socket_server("tcp://$address:$port", $errno, $errstr); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1975 |
if ( !$this->sock ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1976 |
throw new Exception("Could not create the socket: error $errno: $errstr"); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1977 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1978 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1979 |
function destroy() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1980 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1981 |
if ( $this->socket_initted ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1982 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1983 |
// PHP >= 5.2.1 |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1984 |
if ( function_exists('stream_socket_shutdown') ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1985 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1986 |
@stream_socket_shutdown($this->sock, STREAM_SHUT_RDWR); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1987 |
} |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1988 |
while ( !@fclose($this->sock) ) |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1989 |
{ |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1990 |
usleep(100000); |
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1991 |
} |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1992 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1993 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1994 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1995 |
function accept() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1996 |
{ |
48
d643bfb862d8
Replaced multithreading in WebServer with a full multithreading library that properly handles IPC and child management
Dan
parents:
43
diff
changeset
|
1997 |
// the goal of a custom accept() with *_select() is to tick every 200ms to allow signals. |
37
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1998 |
stream_set_blocking($this->sock, 1); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
1999 |
$timeout = 5; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2000 |
$selection = @stream_select($r = array($this->sock), $w = array($this->sock), $e = array($this->sock), $timeout); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2001 |
if ( !$selection ) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2002 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2003 |
return false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2004 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2005 |
$remote = stream_socket_accept($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2006 |
$return = new Socket_Stream(); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2007 |
$return->sock = $remote; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2008 |
$return->socket_initted = true; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2009 |
return $return; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2010 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2011 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2012 |
function soft_shutdown() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2013 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2014 |
fclose($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2015 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2016 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2017 |
function set_timeout($timeout, $usec = false) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2018 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2019 |
return ( $usec ) ? @stream_set_timeout($this->sock, 0, $usec) : @stream_set_timeout($this->sock, $timeout); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2020 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2021 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2022 |
function read_normal($length = 1024) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2023 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2024 |
return @fgets($this->sock, $length); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2025 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2026 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2027 |
function read_binary($length = 1024) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2028 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2029 |
return @fread($this->sock, $length); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2030 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2031 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2032 |
function timed_out() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2033 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2034 |
$md = @stream_get_meta_data($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2035 |
return ( isset($md['timed_out']) ) ? $md['timed_out'] : false; |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2036 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2037 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2038 |
function get_peer_info(&$addr, &$port) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2039 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2040 |
$peer = stream_socket_get_name($this->sock, true); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2041 |
list($addr, $port) = explode(':', $peer); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2042 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2043 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2044 |
function write($data) |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2045 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2046 |
return @fwrite($this->sock, $data); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2047 |
} |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2048 |
|
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2049 |
function is_eof() |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2050 |
{ |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2051 |
return feof($this->sock); |
65e70ada71c9
Major changes to webserver backend. All socket functions are abstracted to allow support for stream_* which seems to be both more widely supported and better at handling blocking and timeouts, at the cost of a small bit of speed. Keep-Alive times out properly and thanks to a bit of IPC code from stream_create_pair(), zombie children are mostly eliminated by proper pcntl_wait() being called when a child shuts down normally, and children die within 0.2sec if the parent receives a SIGTERM or SIGINT, even if the children are waiting on the socket.
Dan
parents:
34
diff
changeset
|
2052 |
} |
23
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2053 |
} |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2054 |
|
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2055 |
/** |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2056 |
* Exception class that allows breaking directly out of a scriptlet. |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2057 |
*/ |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2058 |
|
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2059 |
class HttpExceptionFatal extends Exception |
08225c2eb0b6
Added support for multipart forms, file uploads, and fatal exceptions in PhpHttpd; fixed wrong license tag on WebServer class
Dan
parents:
21
diff
changeset
|
2060 |
{ |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2061 |
} |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2062 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2063 |
/** |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2064 |
* Exception class that will be treated as a scriptlet ending with success. |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2065 |
*/ |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2066 |
|
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2067 |
class HttpSuccess extends Exception |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2068 |
{ |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2069 |
} |
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2070 |
|
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2071 |
/** |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2072 |
* Array of known HTTP status/error codes |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2073 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2074 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2075 |
$http_responses = array( |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2076 |
200 => 'OK', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2077 |
302 => 'Found', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2078 |
307 => 'Temporary Redirect', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2079 |
400 => 'Bad Request', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2080 |
401 => 'Unauthorized', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2081 |
403 => 'Forbidden', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2082 |
404 => 'Not Found', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2083 |
405 => 'Method Not Allowed', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2084 |
406 => 'Not Acceptable', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2085 |
500 => 'Internal Server Error', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2086 |
501 => 'Not Implemented' |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2087 |
); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2088 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2089 |
/** |
24
d275dc8f4203
Added HttpSuccess exception which can be thrown when a scriptlet is done executing normally
Dan
parents:
23
diff
changeset
|
2090 |
* Array of default extension->mimetype mappings |
0
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2091 |
*/ |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2092 |
|
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2093 |
$mime_types = array( |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2094 |
'html' => 'text/html', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2095 |
'htm' => 'text/html', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2096 |
'png' => 'image/png', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2097 |
'gif' => 'image/gif', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2098 |
'jpeg' => 'image/jpeg', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2099 |
'jpg' => 'image/jpeg', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2100 |
'js' => 'text/javascript', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2101 |
'json' => 'text/x-javascript-json', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2102 |
'css' => 'text/css', |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2103 |
'php' => 'application/x-httpd-php' |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2104 |
); |
c63de9eb7045
First commit. Basic things are working and implemented (webserver, templating, DCOP interface)
Dan
parents:
diff
changeset
|
2105 |