xref: /webtrees/app/Services/ServerCheckService.php (revision b4a2f8851f56e7ca6fae19d0a51ff909996d7a30) 
1<?php
2
3/**
4 * webtrees: online genealogy
5 * Copyright (C) 2020 webtrees development team
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18declare(strict_types=1);
19
20namespace Fisharebest\Webtrees\Services;
21
22use Fisharebest\Webtrees\I18N;
23use Illuminate\Support\Collection;
24use SQLite3;
25
26use function array_map;
27use function class_exists;
28use function date;
29use function e;
30use function explode;
31use function extension_loaded;
32use function function_exists;
33use function in_array;
34use function str_ends_with;
35use function str_starts_with;
36use function strtolower;
37use function sys_get_temp_dir;
38use function trim;
39use function version_compare;
40
41use const PATH_SEPARATOR;
42use const PHP_MAJOR_VERSION;
43use const PHP_MINOR_VERSION;
44use const PHP_VERSION;
45
46/**
47 * Check if the server meets the minimum requirements for webtrees.
48 */
49class ServerCheckService
50{
51    private const PHP_SUPPORT_URL   = 'https://www.php.net/supported-versions.php';
52    private const PHP_MINOR_VERSION = PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION;
53    private const PHP_SUPPORT_DATES = [
54        '7.1' => '2019-12-01',
55        '7.2' => '2020-11-30',
56        '7.3' => '2021-12-06',
57        '7.4' => '2022-11-28',
58    ];
59
60    // As required by illuminate/database 5.8
61    private const MINIMUM_SQLITE_VERSION = '3.7.11';
62
63    /**
64     * Things that may cause webtrees to break.
65     *
66     * @param string $driver
67     *
68     * @return Collection<string>
69     */
70    public function serverErrors($driver = ''): Collection
71    {
72        $errors = Collection::make([
73            $this->databaseDriverErrors($driver),
74            $this->checkPhpExtension('mbstring'),
75            $this->checkPhpExtension('iconv'),
76            $this->checkPhpExtension('pcre'),
77            $this->checkPhpExtension('session'),
78            $this->checkPhpExtension('xml'),
79            $this->checkPhpFunction('parse_ini_file'),
80        ]);
81
82        return $errors
83            ->flatten()
84            ->filter();
85    }
86
87    /**
88     * Things that should be fixed, but which won't stop completely webtrees from running.
89     *
90     * @param string $driver
91     *
92     * @return Collection<string>
93     */
94    public function serverWarnings($driver = ''): Collection
95    {
96        $warnings = Collection::make([
97            $this->databaseDriverWarnings($driver),
98            $this->checkPhpExtension('curl'),
99            $this->checkPhpExtension('exif'),
100            $this->checkPhpExtension('fileinfo'),
101            $this->checkPhpExtension('gd'),
102            $this->checkPhpExtension('intl'),
103            $this->checkPhpExtension('zip'),
104            $this->checkPhpExtension('simplexml'),
105            $this->checkPhpIni('file_uploads', true),
106            $this->checkSystemTemporaryFolder(),
107            $this->checkPhpVersion(),
108        ]);
109
110        return $warnings
111            ->flatten()
112            ->filter();
113    }
114
115    /**
116     * Check if a PHP extension is loaded.
117     *
118     * @param string $extension
119     *
120     * @return string
121     */
122    private function checkPhpExtension(string $extension): string
123    {
124        if (!extension_loaded($extension)) {
125            return I18N::translate('The PHP extension “%s” is not installed.', $extension);
126        }
127
128        return '';
129    }
130
131    /**
132     * Check if a PHP setting is correct.
133     *
134     * @param string $varname
135     * @param bool   $expected
136     *
137     * @return string
138     */
139    private function checkPhpIni(string $varname, bool $expected): string
140    {
141        $ini_get = (bool) ini_get($varname);
142
143        if ($expected && $ini_get !== $expected) {
144            return I18N::translate('The PHP.INI setting “%1$s” is disabled.', $varname);
145        }
146
147        if (!$expected && $ini_get !== $expected) {
148            return I18N::translate('The PHP.INI setting “%1$s” is enabled.', $varname);
149        }
150
151        return '';
152    }
153
154    /**
155     * Check if a PHP function is in the list of disabled functions.
156     *
157     * @param string $function
158     *
159     * @return bool
160     */
161    public function isFunctionDisabled(string $function): bool
162    {
163        $disable_functions = explode(',', ini_get('disable_functions'));
164        $disable_functions = array_map(static function (string $func): string {
165            return strtolower(trim($func));
166        }, $disable_functions);
167
168        $function = strtolower($function);
169
170        return in_array($function, $disable_functions, true) || !function_exists($function);
171    }
172
173    /**
174     * Create a warning message for a disabled function.
175     *
176     * @param string $function
177     *
178     * @return string
179     */
180    private function checkPhpFunction(string $function): string
181    {
182        if ($this->isFunctionDisabled($function)) {
183            return I18N::translate('The PHP function “%1$s” is disabled.', $function . '()');
184        }
185
186        return '';
187    }
188
189    /**
190     * Some servers configure their temporary folder in an unaccessible place.
191     */
192    private function checkPhpVersion(): string
193    {
194        $today = date('Y-m-d');
195
196        foreach (self::PHP_SUPPORT_DATES as $version => $end_date) {
197            if ($today > $end_date && version_compare(self::PHP_MINOR_VERSION, $version) <= 0) {
198                return I18N::translate('Your web server is using PHP version %s, which is no longer receiving security updates. You should upgrade to a later version as soon as possible.', PHP_VERSION) . ' <a href="' . e(self::PHP_SUPPORT_URL) . '">' . e(self::PHP_SUPPORT_URL) . '</a>';
199            }
200        }
201
202        return '';
203    }
204
205    /**
206     * Check the
207     *
208     * @return string
209     */
210    private function checkSqliteVersion(): string
211    {
212        if (class_exists(SQLite3::class)) {
213            $sqlite_version = SQLite3::version()['versionString'];
214
215            if (version_compare($sqlite_version, self::MINIMUM_SQLITE_VERSION) < 0) {
216                return I18N::translate('SQLite version %s is installed. SQLite version %s or later is required.', $sqlite_version, self::MINIMUM_SQLITE_VERSION);
217            }
218        }
219
220        return '';
221    }
222
223    /**
224     * Some servers configure their temporary folder in an unaccessible place.
225     */
226    private function checkSystemTemporaryFolder(): string
227    {
228        $open_basedir = ini_get('open_basedir');
229
230        if ($open_basedir === '') {
231            // open_basedir not used.
232            return '';
233        }
234
235        $open_basedirs = explode(PATH_SEPARATOR, $open_basedir);
236
237        $sys_temp_dir = sys_get_temp_dir();
238        $sys_temp_dir = $this->normalizeFolder($sys_temp_dir);
239
240        foreach ($open_basedirs as $dir) {
241            $dir = $this->normalizeFolder($dir);
242
243            if (str_starts_with($sys_temp_dir, $dir)) {
244                return '';
245            }
246        }
247
248        $message = I18N::translate('The server’s temporary folder cannot be accessed.');
249        $message .= '<br>sys_get_temp_dir() = "' . e($sys_temp_dir) . '"';
250        $message .= '<br>ini_get("open_basedir") = "' . e($open_basedir) . '"';
251
252        return $message;
253    }
254
255    /**
256     * Convert a folder name to a canonical form:
257     * - forward slashes.
258     * - trailing slash.
259     * We can't use realpath() as this can trigger open_basedir restrictions,
260     * and we are using this code to find out whether open_basedir will affect us.
261     *
262     * @param string $path
263     *
264     * @return string
265     */
266    private function normalizeFolder(string $path): string
267    {
268        $path = strtr($path, ['\\' => '/']);
269
270        if (str_ends_with($path, '/')) {
271            return $path;
272        }
273
274        return $path . '/';
275    }
276
277    /**
278     * @param string $driver
279     *
280     * @return Collection<string>
281     */
282    private function databaseDriverErrors(string $driver): Collection
283    {
284        switch ($driver) {
285            case 'mysql':
286                return Collection::make([
287                    $this->checkPhpExtension('pdo'),
288                    $this->checkPhpExtension('pdo_mysql'),
289                ]);
290
291            case 'sqlite':
292                return Collection::make([
293                    $this->checkPhpExtension('pdo'),
294                    $this->checkPhpExtension('sqlite3'),
295                    $this->checkPhpExtension('pdo_sqlite'),
296                    $this->checkSqliteVersion(),
297                ]);
298
299            case 'pgsql':
300                return Collection::make([
301                    $this->checkPhpExtension('pdo'),
302                    $this->checkPhpExtension('pdo_pgsql'),
303                ]);
304
305            case 'sqlsvr':
306                return Collection::make([
307                    $this->checkPhpExtension('pdo'),
308                    $this->checkPhpExtension('pdo_odbc'),
309                ]);
310
311            default:
312                return new Collection();
313        }
314    }
315
316    /**
317     * @param string $driver
318     *
319     * @return Collection<string>
320     */
321    private function databaseDriverWarnings(string $driver): Collection
322    {
323        switch ($driver) {
324            case 'sqlite':
325                return new Collection([
326                    I18N::translate('SQLite is only suitable for small sites, testing and evaluation.'),
327                ]);
328
329            case 'pgsql':
330                return new Collection([
331                    I18N::translate('Support for PostgreSQL is experimental.'),
332                ]);
333
334            case 'sqlsvr':
335                return new Collection([
336                    I18N::translate('Support for SQL Server is experimental.'),
337                ]);
338
339            default:
340                return new Collection();
341        }
342    }
343}
344