source: src/router/php7/sapi/litespeed/lsapi_main.c.orig @ 31874

Last change on this file since 31874 was 31874, checked in by brainslayer, 2 months ago

update php

File size: 42.2 KB
Line 
1/*
2   +----------------------------------------------------------------------+
3   | PHP Version 7                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2016 The PHP Group                                |
6   +----------------------------------------------------------------------+
7   | This source file is subject to version 3.01 of the PHP license,      |
8   | that is bundled with this package in the file LICENSE, and is        |
9   | available at through the world-wide-web at the following url:        |
10   | http://www.php.net/license/3_01.txt.                                 |
11   | If you did not receive a copy of the PHP license and are unable to   |
12   | obtain it through the world-wide-web, please send a note to          |
13   | license@php.net so we can mail you a copy immediately.               |
14   +----------------------------------------------------------------------+
15   | Author: George Wang <gwang@litespeedtech.com>                        |
16   +----------------------------------------------------------------------+
17*/
18
19#include "php.h"
20#include "SAPI.h"
21#include "php_main.h"
22#include "php_ini.h"
23#include "php_variables.h"
24#include "zend_highlight.h"
25#include "zend.h"
26
27#include "lsapilib.h"
28
29#include <stdio.h>
30
31#if HAVE_STDLIB_H
32#include <stdlib.h>
33#endif
34
35#if HAVE_UNISTD_H
36#include <unistd.h>
37#endif
38
39#ifdef PHP_WIN32
40
41#include <io.h>
42#include <fcntl.h>
43#include "win32/php_registry.h"
44
45#else
46
47#include <sys/wait.h>
48
49#endif
50
51#include <sys/stat.h>
52
53#if HAVE_SYS_TYPES_H
54
55#include <sys/types.h>
56
57#endif
58
59#if HAVE_SIGNAL_H
60
61#include <signal.h>
62
63#endif
64
65#include <sys/socket.h>
66#include <arpa/inet.h>
67#include <netinet/in.h>
68
69
70#define SAPI_LSAPI_MAX_HEADER_LENGTH 2048
71
72/* Key for each cache entry is dirname(PATH_TRANSLATED).
73 *
74 * NOTE: Each cache entry config_hash contains the combination from all user ini files found in
75 *       the path starting from doc_root throught to dirname(PATH_TRANSLATED).  There is no point
76 *       storing per-file entries as it would not be possible to detect added / deleted entries
77 *       between separate files.
78 */
79typedef struct _user_config_cache_entry {
80    time_t expires;
81    HashTable user_config;
82} user_config_cache_entry;
83static HashTable user_config_cache;
84
85static int  lsapi_mode       = 0;
86static char *php_self        = "";
87static char *script_filename = "";
88static int  source_highlight = 0;
89static int  ignore_php_ini   = 0;
90static char * argv0 = NULL;
91static int  engine = 1;
92static int  parse_user_ini   = 0;
93#ifdef ZTS
94zend_compiler_globals    *compiler_globals;
95zend_executor_globals    *executor_globals;
96php_core_globals         *core_globals;
97sapi_globals_struct      *sapi_globals;
98void ***tsrm_ls;
99#endif
100
101zend_module_entry litespeed_module_entry;
102
103static void init_sapi_from_env(sapi_module_struct *sapi_module)
104{
105    char *p;
106    p = getenv("LSPHPRC");
107    if (p)
108        sapi_module->php_ini_path_override = p;
109}
110
111/* {{{ php_lsapi_startup
112 */
113static int php_lsapi_startup(sapi_module_struct *sapi_module)
114{
115    if (php_module_startup(sapi_module, NULL, 0)==FAILURE) {
116        return FAILURE;
117    }
118    argv0 = sapi_module->executable_location;
119    return SUCCESS;
120}
121/* }}} */
122
123/* {{{ sapi_lsapi_ini_defaults */
124
125/* overwriteable ini defaults must be set in sapi_cli_ini_defaults() */
126#define INI_DEFAULT(name,value)\
127    ZVAL_STRING(tmp, value, 0);\
128    zend_hash_update(configuration_hash, name, sizeof(name), tmp, sizeof(zval), (void**)&entry);\
129    Z_STRVAL_P(entry) = zend_strndup(Z_STRVAL_P(entry), Z_STRLEN_P(entry))
130
131static void sapi_lsapi_ini_defaults(HashTable *configuration_hash)
132{
133    zval *tmp, *entry;
134
135#if PHP_MAJOR_VERSION > 4
136/*
137    MAKE_STD_ZVAL(tmp);
138
139    INI_DEFAULT("register_long_arrays", "0");
140
141    FREE_ZVAL(tmp);
142*/
143#endif
144
145}
146/* }}} */
147
148
149/* {{{ sapi_lsapi_ub_write
150 */
151static size_t sapi_lsapi_ub_write(const char *str, size_t str_length)
152{
153    int ret;
154    int remain;
155    if ( lsapi_mode ) {
156        ret  = LSAPI_Write( str, str_length );
157        if ( ret < str_length ) {
158            php_handle_aborted_connection();
159            return str_length - ret;
160        }
161    } else {
162        remain = str_length;
163        while( remain > 0 ) {
164            ret = write( 1, str, remain );
165            if ( ret <= 0 ) {
166                php_handle_aborted_connection();
167                return str_length - remain;
168            }
169            str += ret;
170            remain -= ret;
171        }
172    }
173    return str_length;
174}
175/* }}} */
176
177
178/* {{{ sapi_lsapi_flush
179 */
180static void sapi_lsapi_flush( void * server_context )
181{
182    if ( lsapi_mode ) {
183        if ( LSAPI_Flush() == -1) {
184            php_handle_aborted_connection();
185        }
186    }
187}
188/* }}} */
189
190
191/* {{{ sapi_lsapi_deactivate
192 */
193static int sapi_lsapi_deactivate(void)
194{
195    if ( SG(request_info).path_translated )
196    {
197        efree( SG(request_info).path_translated );
198        SG(request_info).path_translated = NULL;
199    }
200
201    return SUCCESS;
202}
203/* }}} */
204
205
206
207
208/* {{{ sapi_lsapi_getenv
209 */
210static char *sapi_lsapi_getenv( char * name, size_t name_len )
211{
212    if ( lsapi_mode ) {
213        return LSAPI_GetEnv( name );
214    } else {
215        return getenv( name );
216    }
217}
218/* }}} */
219
220
221static int add_variable( const char * pKey, int keyLen, const char * pValue, int valLen,
222                         void * arg )
223{
224    int filter_arg = (Z_ARR_P((zval *)arg) == Z_ARR(PG(http_globals)[TRACK_VARS_ENV]))
225        ? PARSE_ENV : PARSE_SERVER;
226    char * new_val = (char *) pValue;
227    size_t new_val_len;
228
229    if (sapi_module.input_filter(filter_arg, (char *)pKey, &new_val, valLen, &new_val_len)) {
230        php_register_variable_safe((char *)pKey, new_val, new_val_len, (zval *)arg );
231    }
232    return 1;
233}
234
235static void litespeed_php_import_environment_variables(zval *array_ptr)
236{
237        char buf[128];
238        char **env, *p, *t = buf;
239        size_t alloc_size = sizeof(buf);
240        unsigned long nlen; /* ptrdiff_t is not portable */
241
242    if (Z_TYPE(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&
243        Z_ARR_P(array_ptr) != Z_ARR(PG(http_globals)[TRACK_VARS_ENV]) &&
244        zend_hash_num_elements(Z_ARRVAL(PG(http_globals)[TRACK_VARS_ENV])) > 0
245        ) {
246        zval_dtor(array_ptr);
247        ZVAL_DUP(array_ptr, &PG(http_globals)[TRACK_VARS_ENV]);
248                return;
249    } else if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY &&
250        Z_ARR_P(array_ptr) != Z_ARR(PG(http_globals)[TRACK_VARS_SERVER]) &&
251        zend_hash_num_elements(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER])) > 0
252        ) {
253        zval_dtor(array_ptr);
254        ZVAL_DUP(array_ptr, &PG(http_globals)[TRACK_VARS_SERVER]);
255                return;
256        }
257
258        for (env = environ; env != NULL && *env != NULL; env++) {
259                p = strchr(*env, '=');
260                if (!p) {                               /* malformed entry? */
261                        continue;
262                }
263                nlen = p - *env;
264                if (nlen >= alloc_size) {
265                        alloc_size = nlen + 64;
266                        t = (t == buf ? emalloc(alloc_size): erealloc(t, alloc_size));
267                }
268                memcpy(t, *env, nlen);
269                t[nlen] = '\0';
270                add_variable(t, nlen, p + 1, strlen( p + 1 ), array_ptr);
271        }
272        if (t != buf && t != NULL) {
273                efree(t);
274        }
275}
276
277/* {{{ sapi_lsapi_register_variables
278 */
279static void sapi_lsapi_register_variables(zval *track_vars_array)
280{
281    char * php_self = "";
282    if ( lsapi_mode ) {
283        if ( (SG(request_info).request_uri ) )
284            php_self = (SG(request_info).request_uri );
285
286        litespeed_php_import_environment_variables(track_vars_array);
287
288                LSAPI_ForeachHeader( add_variable, track_vars_array );
289                LSAPI_ForeachEnv( add_variable, track_vars_array );
290                add_variable("PHP_SELF", 8, php_self, strlen( php_self ), track_vars_array );
291    } else {
292        php_import_environment_variables(track_vars_array);
293
294        php_register_variable("PHP_SELF", php_self, track_vars_array);
295        php_register_variable("SCRIPT_NAME", php_self, track_vars_array);
296        php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array);
297        php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array);
298        php_register_variable("DOCUMENT_ROOT", "", track_vars_array);
299
300    }
301}
302/* }}} */
303
304
305/* {{{ sapi_lsapi_read_post
306 */
307static size_t sapi_lsapi_read_post(char *buffer, size_t count_bytes)
308{
309    if ( lsapi_mode ) {
310        return LSAPI_ReadReqBody( buffer, (unsigned long long)count_bytes );
311    } else {
312        return 0;
313    }
314}
315/* }}} */
316
317
318
319
320/* {{{ sapi_lsapi_read_cookies
321 */
322static char *sapi_lsapi_read_cookies(void)
323{
324    if ( lsapi_mode ) {
325        return LSAPI_GetHeader( H_COOKIE );
326    } else {
327        return NULL;
328    }
329}
330/* }}} */
331
332
333/* {{{ sapi_lsapi_send_headers
334 */
335static int sapi_lsapi_send_headers(sapi_headers_struct *sapi_headers)
336{
337    sapi_header_struct  *h;
338    zend_llist_position pos;
339    if ( lsapi_mode ) {
340        LSAPI_SetRespStatus( SG(sapi_headers).http_response_code );
341
342        h = zend_llist_get_first_ex(&sapi_headers->headers, &pos);
343        while (h) {
344            if ( h->header_len > 0 ) {
345                LSAPI_AppendRespHeader(h->header, h->header_len);
346            }
347            h = zend_llist_get_next_ex(&sapi_headers->headers, &pos);
348        }
349        if (SG(sapi_headers).send_default_content_type) {
350            char    *hd;
351            int     len;
352            char    headerBuf[SAPI_LSAPI_MAX_HEADER_LENGTH];
353
354            hd = sapi_get_default_content_type();
355            len = snprintf( headerBuf, SAPI_LSAPI_MAX_HEADER_LENGTH - 1,
356                            "Content-type: %s", hd );
357            efree(hd);
358
359            LSAPI_AppendRespHeader( headerBuf, len );
360        }
361    }
362    LSAPI_FinalizeRespHeaders();
363    return SAPI_HEADER_SENT_SUCCESSFULLY;
364
365
366}
367/* }}} */
368
369
370/* {{{ sapi_lsapi_send_headers
371 */
372static void sapi_lsapi_log_message(char *message)
373{
374    char buf[8192];
375    int len = strlen( message );
376    if ( *(message + len - 1 ) != '\n' )
377    {
378        snprintf( buf, 8191, "%s\n", message );
379        message = buf;
380        ++len;
381    }
382    LSAPI_Write_Stderr( message, len);
383}
384/* }}} */
385
386/* Set to 1 to turn on log messages useful during development:
387 */
388#if 0
389static void log_message (const char *fmt, ...)
390{
391    va_list ap;
392    va_start(ap, fmt);
393    char buf[0x100];
394    vsnprintf(buf, sizeof(buf), fmt, ap);
395    va_end(ap);
396    sapi_lsapi_log_message(buf
397#if PHP_MAJOR_VERSION > 7 || (PHP_MAJOR_VERSION == 7 && PHP_MINOR_VERSION >= 1)
398                               , 0
399#endif
400                                  );
401}
402#define DEBUG_MESSAGE(fmt, ...) log_message("LS:%d " fmt "\n", __LINE__, ##__VA_ARGS__)
403#else
404#define DEBUG_MESSAGE(fmt, ...)
405#endif
406
407/* {{{ sapi_module_struct cgi_sapi_module
408 */
409static sapi_module_struct lsapi_sapi_module =
410{
411    "litespeed",
412    "LiteSpeed V6.10",
413
414    php_lsapi_startup,              /* startup */
415    php_module_shutdown_wrapper,    /* shutdown */
416
417    NULL,                           /* activate */
418    sapi_lsapi_deactivate,          /* deactivate */
419
420    sapi_lsapi_ub_write,            /* unbuffered write */
421    sapi_lsapi_flush,               /* flush */
422    NULL,                           /* get uid */
423    sapi_lsapi_getenv,              /* getenv */
424
425    php_error,                      /* error handler */
426
427    NULL,                           /* header handler */
428    sapi_lsapi_send_headers,        /* send headers handler */
429    NULL,                           /* send header handler */
430
431    sapi_lsapi_read_post,           /* read POST data */
432    sapi_lsapi_read_cookies,        /* read Cookies */
433
434    sapi_lsapi_register_variables,  /* register server variables */
435    sapi_lsapi_log_message,         /* Log message */
436
437    NULL,                           /* php.ini path override */
438    NULL,                           /* block interruptions */
439    NULL,                           /* unblock interruptions */
440    NULL,                           /* default post reader */
441    NULL,                           /* treat data */
442    NULL,                           /* executable location */
443
444    0,                              /* php.ini ignore */
445
446    STANDARD_SAPI_MODULE_PROPERTIES
447
448};
449/* }}} */
450
451static void init_request_info( void )
452{
453    char * pContentType = LSAPI_GetHeader( H_CONTENT_TYPE );
454    char * pAuth;
455
456    SG(request_info).content_type = pContentType ? pContentType : "";
457    SG(request_info).request_method = LSAPI_GetRequestMethod();
458    SG(request_info).query_string = LSAPI_GetQueryString();
459    SG(request_info).request_uri = LSAPI_GetScriptName();
460    SG(request_info).content_length = LSAPI_GetReqBodyLen();
461    SG(request_info).path_translated = estrdup( LSAPI_GetScriptFileName());
462
463    /* It is not reset by zend engine, set it to 200. */
464    SG(sapi_headers).http_response_code = 200;
465
466    pAuth = LSAPI_GetHeader( H_AUTHORIZATION );
467    php_handle_auth_data(pAuth);
468}
469
470static char s_cur_chdir[4096] = "";
471
472static int lsapi_chdir_primary_script( zend_file_handle * file_handle )
473{
474#if PHP_MAJOR_VERSION > 4
475    char * p;
476    char ch;
477
478    SG(options) |= SAPI_OPTION_NO_CHDIR;
479    getcwd( s_cur_chdir, sizeof( s_cur_chdir ) );
480
481    p = strrchr( file_handle->filename, '/' );
482    if ( *p )
483    {
484        *p = 0;
485        if ( strcmp( file_handle->filename, s_cur_chdir ) != 0 ) {
486            chdir( file_handle->filename );
487        }
488        *p++ = '/';
489        ch = *p;
490        *p = 0;
491        if ( !CWDG(cwd).cwd ||
492             ( strcmp( file_handle->filename, CWDG(cwd).cwd ) != 0 ) ) {
493            CWDG(cwd).cwd_length = p - file_handle->filename;
494            CWDG(cwd).cwd = (char *) realloc(CWDG(cwd).cwd, CWDG(cwd).cwd_length+1);
495            memmove( CWDG(cwd).cwd, file_handle->filename, CWDG(cwd).cwd_length+1 );
496        }
497        *p = ch;
498    }
499    /* virtual_file_ex(&CWDG(cwd), file_handle->filename, NULL, CWD_REALPATH); */
500#else
501    VCWD_CHDIR_FILE( file_handle->filename );
502#endif
503    return 0;
504}
505
506static int lsapi_fopen_primary_script( zend_file_handle * file_handle )
507{
508    FILE * fp;
509    char * p;
510    fp = fopen( SG(request_info).path_translated, "rb" );
511    if ( !fp )
512    {
513        return -1;
514    }
515    file_handle->type = ZEND_HANDLE_FP;
516    file_handle->handle.fp = fp;
517    file_handle->filename = SG(request_info).path_translated;
518    file_handle->free_filename = 0;
519    file_handle->opened_path = NULL;
520
521    lsapi_chdir_primary_script( file_handle );
522
523    return 0;
524}
525
526static int lsapi_execute_script( zend_file_handle * file_handle)
527{
528    char *p;
529    int len;
530    file_handle->type = ZEND_HANDLE_FILENAME;
531    file_handle->handle.fd = 0;
532    file_handle->filename = SG(request_info).path_translated;
533    file_handle->free_filename = 0;
534    file_handle->opened_path = NULL;
535
536    p = argv0;
537    *p++ = ':';
538    len = strlen( SG(request_info).path_translated );
539    if ( len > 45 )
540        len = len - 45;
541    else
542        len = 0;
543    memccpy( p, SG(request_info).path_translated + len, 0, 46 );
544
545    php_execute_script(file_handle);
546    return 0;
547
548}
549
550static int lsapi_activate_user_ini();
551
552static int lsapi_module_main(int show_source)
553{
554    zend_file_handle file_handle = {0};
555
556    if (php_request_startup() == FAILURE ) {
557        return -1;
558    }
559   
560    if (parse_user_ini && lsapi_activate_user_ini() == FAILURE) {
561        return -1;
562    }
563
564    if (show_source) {
565        zend_syntax_highlighter_ini syntax_highlighter_ini;
566
567        php_get_highlight_struct(&syntax_highlighter_ini);
568        highlight_file(SG(request_info).path_translated, &syntax_highlighter_ini);
569    } else {
570        lsapi_execute_script( &file_handle);
571    }
572    zend_try {
573        php_request_shutdown(NULL);
574        memset( argv0, 0, 46 );
575    } zend_end_try();
576    return 0;
577}
578
579
580static int alter_ini( const char * pKey, int keyLen, const char * pValue, int valLen,
581                void * arg )
582{
583#if PHP_MAJOR_VERSION >= 7
584    zend_string * psKey;
585#endif
586    int type = ZEND_INI_PERDIR;
587    if ( '\001' == *pKey ) {
588        ++pKey;
589        if ( *pKey == 4 ) {
590            type = ZEND_INI_SYSTEM;
591        }
592        ++pKey;
593        --keyLen;
594        if (( keyLen == 7 )&&( strncasecmp( pKey, "engine", 6 )== 0 ))
595        {
596            if ( *pValue == '0' )
597                engine = 0;
598        }
599        else
600        {
601#if PHP_MAJOR_VERSION >= 7
602            --keyLen;
603            psKey = zend_string_init(pKey, keyLen, 1);
604            zend_alter_ini_entry_chars(psKey,
605                             (char *)pValue, valLen,
606                             type, PHP_INI_STAGE_ACTIVATE);
607            zend_string_release(psKey);
608#else
609            zend_alter_ini_entry((char *)pKey, keyLen,
610                             (char *)pValue, valLen,
611                             type, PHP_INI_STAGE_ACTIVATE);
612#endif
613        }
614    }
615    return 1;
616}
617
618static void user_config_cache_entry_dtor(zval *el)
619{
620    user_config_cache_entry *entry = (user_config_cache_entry *)Z_PTR_P(el);
621    zend_hash_destroy(&entry->user_config);
622    free(entry);
623}
624
625static void user_config_cache_init()
626{
627    zend_hash_init(&user_config_cache, 0, NULL, user_config_cache_entry_dtor, 1);
628}
629
630static int pathlen_without_trailing_slash(char *path)
631{
632    int len = (int)strlen(path);
633    while (len > 1 && /* mind "/" as root dir */
634           path[len-1] == DEFAULT_SLASH)
635    {
636        --len;
637    }
638    return len;
639}
640
641static inline char* skip_slash(char *s)
642{
643    while (*s == DEFAULT_SLASH) {
644        ++s;
645    }
646    return s;
647}
648
649/**
650 * Walk down the path_stop starting at path_start.
651 *
652 * If path_start = "/path1" and path_stop = "/path1/path2/path3"
653 * the callback will be called 3 times with the next args:
654 *
655 *   1. "/path1/path2/path3"
656 *             ^ end
657 *       ^ start
658 *   2. "/path1/path2/path3"
659 *                   ^ end
660 *       ^ start
661 *   3. "/path1/path2/path3"
662 *                         ^ end
663 *       ^ start
664 *
665 * path_stop has to be a subdir of path_start
666 * or to be path_start itself.
667 *
668 * Both path args have to be absolute.
669 * Trailing slashes are allowed.
670 * NULL or empty string args are not allowed.
671 */
672static void walk_down_the_path(char* path_start,
673                               char* path_stop,
674                               void (*cb)(char* begin,
675                                          char* end,
676                                          void* data),
677                               void* data)
678{
679    char *pos = path_stop + pathlen_without_trailing_slash(path_start);
680    cb(path_stop, pos, data);
681
682    while ((pos = skip_slash(pos))[0]) {
683        pos = strchr(pos, DEFAULT_SLASH);
684        if (!pos) {
685            /* The last token without trailing slash
686             */
687            cb(path_stop, path_stop + strlen(path_stop), data);
688            return;
689        }
690        cb(path_stop, pos, data);
691    }
692}
693
694
695typedef struct {
696    char *path;
697    uint path_len;
698    char *doc_root;
699    user_config_cache_entry *entry;
700} _lsapi_activate_user_ini_ctx;
701
702typedef int (*fn_activate_user_ini_chain_t)
703        (_lsapi_activate_user_ini_ctx *ctx, void* next);
704
705static int lsapi_activate_user_ini_basic_checks(_lsapi_activate_user_ini_ctx *ctx,
706                                                void* next)
707{
708    int rc = SUCCESS;
709    fn_activate_user_ini_chain_t *fn_next = next;
710
711    if (!PG(user_ini_filename) || !*PG(user_ini_filename)) {
712        return SUCCESS;
713    }
714
715    /* PATH_TRANSLATED should be defined at this stage */
716    ctx->path = SG(request_info).path_translated;
717    if (!ctx->path || !*ctx->path) {
718        return FAILURE;
719    }
720
721    ctx->doc_root = sapi_lsapi_getenv("DOCUMENT_ROOT", 0);
722    DEBUG_MESSAGE("doc_root: %s", ctx->doc_root);
723
724    if (*fn_next) {
725        rc = (*fn_next)(ctx, fn_next + 1);
726    }
727
728    return rc;
729}
730
731static int lsapi_activate_user_ini_mk_path(_lsapi_activate_user_ini_ctx *ctx,
732                                           void* next)
733{
734    char *path;
735    int rc = SUCCESS;
736    fn_activate_user_ini_chain_t *fn_next = next;
737
738    /* Extract dir name from path_translated * and store it in 'path' */
739    ctx->path_len = strlen(ctx->path);
740    path = ctx->path = estrndup(SG(request_info).path_translated, ctx->path_len);
741    if (!path)
742        return FAILURE;
743    ctx->path_len = zend_dirname(path, ctx->path_len);
744    DEBUG_MESSAGE("dirname: %s", ctx->path);
745
746    if (*fn_next) {
747        rc = (*fn_next)(ctx, fn_next + 1);
748    }
749
750    efree(path);
751    return rc;
752}
753
754static int lsapi_activate_user_ini_mk_realpath(_lsapi_activate_user_ini_ctx *ctx,
755                                               void* next)
756{
757    char *real_path;
758    int rc = SUCCESS;
759    fn_activate_user_ini_chain_t *fn_next = next;
760
761    if (!IS_ABSOLUTE_PATH(ctx->path, ctx->path_len)) {
762        real_path = tsrm_realpath(ctx->path, NULL);
763        if (!real_path) {
764            return SUCCESS;
765        }
766        ctx->path = real_path;
767        ctx->path_len = strlen(ctx->path);
768        DEBUG_MESSAGE("calculated tsrm realpath: %s", real_path);
769    } else {
770        DEBUG_MESSAGE("%s is an absolute path", ctx->path);
771        real_path = NULL;
772    }
773
774    if (*fn_next) {
775        rc = (*fn_next)(ctx, fn_next + 1);
776    }
777
778    if (real_path)
779        efree(real_path);
780    return rc;
781}
782
783static int lsapi_activate_user_ini_mk_user_config(_lsapi_activate_user_ini_ctx *ctx,
784                                                  void* next)
785{
786    fn_activate_user_ini_chain_t *fn_next = next;
787
788    /* Find cached config entry: If not found, create one */
789    ctx->entry = zend_hash_str_find_ptr(&user_config_cache, ctx->path, ctx->path_len);
790
791    if (ctx->entry) {
792        DEBUG_MESSAGE("found entry for %s", ctx->path);
793    } else {
794        DEBUG_MESSAGE("entry for %s not found, creating new entry", ctx->path);
795        ctx->entry = pemalloc(sizeof(user_config_cache_entry), 1);
796        ctx->entry->expires = 0;
797        zend_hash_init(&ctx->entry->user_config, 0, NULL,
798                       config_zval_dtor, 1);
799        zend_hash_str_update_ptr(&user_config_cache, ctx->path,
800                                            ctx->path_len, ctx->entry);
801    }
802
803    if (*fn_next) {
804        return (*fn_next)(ctx, fn_next + 1);
805    } else {
806        return SUCCESS;
807    }
808}
809
810static void walk_down_the_path_callback(char* begin,
811                                        char* end,
812                                        void* data)
813{
814    _lsapi_activate_user_ini_ctx *ctx = data;
815    char tmp = end[0];
816    end[0] = 0;
817    DEBUG_MESSAGE("parsing %s%c%s", begin, DEFAULT_SLASH, PG(user_ini_filename));
818    php_parse_user_ini_file(begin, PG(user_ini_filename), &ctx->entry->user_config);
819    end[0] = tmp;
820}
821
822static int lsapi_activate_user_ini_walk_down_the_path(_lsapi_activate_user_ini_ctx *ctx,
823                                                      void* next)
824{
825    time_t request_time = sapi_get_request_time();
826    uint path_len, docroot_len;
827    int rc = SUCCESS;
828    fn_activate_user_ini_chain_t *fn_next = next;
829
830    if (!ctx->entry->expires || request_time > ctx->entry->expires)
831    {
832        docroot_len = ctx->doc_root && ctx->doc_root[0]
833                    ? pathlen_without_trailing_slash(ctx->doc_root)
834                    : 0;
835
836        int is_outside_of_docroot = !docroot_len ||
837                ctx->path_len < docroot_len ||
838                strncmp(ctx->path, ctx->doc_root, docroot_len) != 0;
839
840        if (is_outside_of_docroot) {
841            php_parse_user_ini_file(ctx->path, PG(user_ini_filename),
842                                    &ctx->entry->user_config);
843        } else {
844            walk_down_the_path(ctx->doc_root, ctx->path,
845                               &walk_down_the_path_callback, ctx);
846        }
847
848        ctx->entry->expires = request_time + PG(user_ini_cache_ttl);
849    }
850
851    if (*fn_next) {
852        rc = (*fn_next)(ctx, fn_next + 1);
853    }
854
855    return rc;
856}
857
858static int lsapi_activate_user_ini_finally(_lsapi_activate_user_ini_ctx *ctx,
859                                           void* next)
860{
861    int rc = SUCCESS;
862    fn_activate_user_ini_chain_t *fn_next = next;
863
864    DEBUG_MESSAGE("calling php_ini_activate_config()");
865    php_ini_activate_config(&ctx->entry->user_config, PHP_INI_PERDIR,
866                            PHP_INI_STAGE_HTACCESS);
867
868    if (*fn_next) {
869        rc = (*fn_next)(ctx, fn_next + 1);
870    }
871
872    return rc;
873}
874
875static int lsapi_activate_user_ini(TSRMLS_D)
876{
877    _lsapi_activate_user_ini_ctx ctx;
878    /**
879     * The reason to have this function list stacked
880     * is each function now can define a scoped destructor.
881     *
882     * Passing control via function pointer is a sign of low coupling,
883     * which means dependencies between these functions are to be
884     * controlled from a single place
885     * (here below, by modifying this function list order)
886     */
887    static const fn_activate_user_ini_chain_t fn_chain[] = {
888        &lsapi_activate_user_ini_basic_checks,
889        &lsapi_activate_user_ini_mk_path,
890        &lsapi_activate_user_ini_mk_realpath,
891        &lsapi_activate_user_ini_mk_user_config,
892        &lsapi_activate_user_ini_walk_down_the_path,
893        &lsapi_activate_user_ini_finally,
894        NULL
895    };
896   
897    return fn_chain[0](&ctx, (fn_activate_user_ini_chain_t*)(fn_chain + 1));
898}
899
900
901static void override_ini()
902{
903
904    LSAPI_ForeachSpecialEnv( alter_ini, NULL );
905
906}
907
908
909static int processReq( void )
910{
911    int ret = 0;
912    zend_first_try {
913
914        /* avoid server_context==NULL checks */
915        SG(server_context) = (void *) 1;
916
917        engine = 1;
918        override_ini();
919
920        if ( engine ) {
921            init_request_info(  );
922
923            if ( lsapi_module_main( source_highlight ) == -1 ) {
924                ret = -1;
925            }
926        } else {
927            LSAPI_AppendRespHeader( "status: 403", 11 );
928            LSAPI_AppendRespHeader( "content-type: text/html", 23 );
929            LSAPI_Write( "Forbidden: PHP engine is disable.\n", 34 );
930        }
931    } zend_end_try();
932    return ret;
933}
934
935static void cli_usage( void )
936{
937    static const char * usage =
938        "Usage: php\n"
939        "      php -[b|c|n|h|i|q|s|v|?] [<file>] [args...]\n"
940        "  Run in LSAPI mode, only '-b', '-s' and '-c' are effective\n"
941        "  Run in Command Line Interpreter mode when parameters are specified\n"
942        "\n"
943        "  -b <address:port>|<port> Bind Path for external LSAPI Server mode\n"
944        "  -c <path>|<file> Look for php.ini file in this directory\n"
945        "  -n    No php.ini file will be used\n"
946        "  -h    This help\n"
947        "  -i    PHP information\n"
948        "  -l    Syntax check\n"
949        "  -q    Quiet-mode.  Suppress HTTP Header output.\n"
950        "  -s    Display colour syntax highlighted source.\n"
951        "  -v    Version number\n"
952        "  -?    This help\n"
953        "\n"
954        "  args...    Arguments passed to script.\n";
955    php_output_startup();
956    php_output_activate();
957    php_printf( "%s", usage );
958#ifdef PHP_OUTPUT_NEWAPI
959    php_output_end_all();
960#else
961    php_end_ob_buffers(1);
962#endif
963}
964
965static int parse_opt( int argc, char * argv[], int *climode,
966                        char **php_ini_path, char ** php_bind )
967{
968    char ** p = &argv[1];
969    char ** argend= &argv[argc];
970    int c;
971    while (( p < argend )&&(**p == '-' )) {
972        c = *((*p)+1);
973        ++p;
974        switch( c ) {
975        case 'b':
976            if ( p >= argend ) {
977                fprintf( stderr, "TCP or socket address must be specified following '-b' option.\n");
978                return -1;
979            }
980            *php_bind = strdup(*p++);
981            break;
982
983        case 'c':
984            if ( p >= argend ) {
985                fprintf( stderr, "<path> or <file> must be specified following '-c' option.\n");
986
987                return -1;
988            }
989            *php_ini_path = strdup( *p++ );
990            break;
991        case 's':
992            source_highlight = 1;
993            break;
994        case 'n':
995            ignore_php_ini = 1;
996            break;
997        case '?':
998            if ( *((*(p-1))+2) == 's' )
999                exit( 99 );
1000        case 'h':
1001        case 'i':
1002        case 'l':
1003        case 'q':
1004        case 'v':
1005        default:
1006            *climode = 1;
1007            break;
1008        }
1009    }
1010    if ( p - argv < argc ) {
1011        *climode = 1;
1012    }
1013    return 0;
1014}
1015
1016static int cli_main( int argc, char * argv[] )
1017{
1018
1019    static const char * ini_defaults[] = {
1020        "report_zend_debug",    "0",
1021        "display_errors",       "1",
1022        "register_argc_argv",   "1",
1023        "html_errors",          "0",
1024        "implicit_flush",       "1",
1025        "output_buffering",     "0",
1026        "max_execution_time",   "0",
1027        "max_input_time",       "-1",
1028        NULL
1029    };
1030
1031    const char ** ini;
1032    char ** p = &argv[1];
1033    char ** argend= &argv[argc];
1034    int ret = -1;
1035    int c;
1036#if PHP_MAJOR_VERSION >= 7
1037        zend_string * psKey;
1038#endif
1039    lsapi_mode = 0;        /* enter CLI mode */
1040
1041#ifdef PHP_WIN32
1042    _fmode = _O_BINARY;            /*sets default for file streams to binary */
1043    setmode(_fileno(stdin), O_BINARY);    /* make the stdio mode be binary */
1044    setmode(_fileno(stdout), O_BINARY);   /* make the stdio mode be binary */
1045    setmode(_fileno(stderr), O_BINARY);   /* make the stdio mode be binary */
1046#endif
1047
1048    zend_first_try     {
1049        SG(server_context) = (void *) 1;
1050
1051        zend_uv.html_errors = 0; /* tell the engine we're in non-html mode */
1052        CG(in_compilation) = 0; /* not initialized but needed for several options */
1053        SG(options) |= SAPI_OPTION_NO_CHDIR;
1054       
1055#if PHP_MAJOR_VERSION < 7
1056        EG(uninitialized_zval_ptr) = NULL;
1057#endif
1058        for( ini = ini_defaults; *ini; ini+=2 ) {
1059#if PHP_MAJOR_VERSION >= 7
1060                        psKey = zend_string_init(*ini, strlen( *ini ), 1);
1061            zend_alter_ini_entry_chars(psKey,
1062                                (char *)*(ini+1), strlen( *(ini+1) ),
1063                                PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
1064                        zend_string_release(psKey);
1065#else
1066            zend_alter_ini_entry( (char *)*ini, strlen( *ini )+1,
1067                                (char *)*(ini+1), strlen( *(ini+1) ),
1068                                PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
1069#endif
1070        }
1071
1072        while (( p < argend )&&(**p == '-' )) {
1073            c = *((*p)+1);
1074            ++p;
1075            switch( c ) {
1076            case 'q':
1077                break;
1078            case 'i':
1079                if (php_request_startup() != FAILURE) {
1080                    php_print_info(0xFFFFFFFF);
1081#ifdef PHP_OUTPUT_NEWAPI
1082                    php_output_end_all();
1083#else
1084                    php_end_ob_buffers(1);
1085#endif
1086                    php_request_shutdown( NULL );
1087                    ret = 0;
1088                }
1089                break;
1090            case 'v':
1091                if (php_request_startup() != FAILURE) {
1092#if ZEND_DEBUG
1093                    php_printf("PHP %s (%s) (DEBUG)\nCopyright (c) 1997-2016 The PHP Group\n%s", PHP_VERSION, sapi_module.name, get_zend_version());
1094#else
1095                    php_printf("PHP %s (%s)\nCopyright (c) 1997-2016 The PHP Group\n%s", PHP_VERSION, sapi_module.name, get_zend_version());
1096#endif
1097#ifdef PHP_OUTPUT_NEWAPI
1098                    php_output_end_all();
1099#else
1100                    php_end_ob_buffers(1);
1101#endif
1102                    php_request_shutdown( NULL );
1103                    ret = 0;
1104                }
1105                break;
1106            case 'c':
1107                ++p;
1108            /* fall through */
1109            case 's':
1110                break;
1111            case 'l':
1112                source_highlight = 2;
1113                break;
1114            case 'h':
1115            case '?':
1116            default:
1117                cli_usage();
1118                ret = 0;
1119                break;
1120
1121            }
1122        }
1123        if ( ret == -1 ) {
1124            if ( *p ) {
1125                zend_file_handle file_handle = {0};
1126
1127                file_handle.type = ZEND_HANDLE_FP;
1128                file_handle.handle.fp = VCWD_FOPEN(*p, "rb");
1129
1130                if ( file_handle.handle.fp ) {
1131                    script_filename = *p;
1132                    php_self = *p;
1133
1134                    SG(request_info).path_translated = estrdup(*p);
1135                    SG(request_info).argc = argc - (p - argv);
1136                    SG(request_info).argv = p;
1137
1138                    if (php_request_startup() == FAILURE ) {
1139                        fclose( file_handle.handle.fp );
1140                        ret = 2;
1141                    } else {
1142                        if (source_highlight == 1) {
1143                            zend_syntax_highlighter_ini syntax_highlighter_ini;
1144
1145                            php_get_highlight_struct(&syntax_highlighter_ini);
1146                            highlight_file(SG(request_info).path_translated, &syntax_highlighter_ini);
1147                        } else if (source_highlight == 2) {
1148                            file_handle.filename = *p;
1149                            file_handle.free_filename = 0;
1150                            file_handle.opened_path = NULL;
1151                            ret = php_lint_script(&file_handle);
1152                            if (ret==SUCCESS) {
1153                                zend_printf("No syntax errors detected in %s\n", file_handle.filename);
1154                            } else {
1155                                zend_printf("Errors parsing %s\n", file_handle.filename);
1156                            }
1157
1158                        } else {
1159                            file_handle.filename = *p;
1160                            file_handle.free_filename = 0;
1161                            file_handle.opened_path = NULL;
1162
1163                            php_execute_script(&file_handle);
1164                            ret = EG(exit_status);
1165                       }
1166
1167                        php_request_shutdown( NULL );
1168                    }
1169                } else {
1170                    php_printf("Could not open input file: %s.\n", *p);
1171                }
1172            } else {
1173                cli_usage();
1174            }
1175        }
1176
1177    }zend_end_try();
1178
1179    php_module_shutdown();
1180
1181#ifdef ZTS
1182    tsrm_shutdown();
1183#endif
1184    return ret;
1185}
1186
1187static int s_stop;
1188void litespeed_cleanup(int signal)
1189{
1190    s_stop = signal;
1191}
1192
1193
1194void start_children( int children )
1195{
1196    struct sigaction act, old_term, old_quit, old_int, old_usr1;
1197    int running = 0;
1198    int status;
1199    pid_t pid;
1200
1201    /* Create a process group */
1202    setsid();
1203
1204    /* Set up handler to kill children upon exit */
1205    act.sa_flags = 0;
1206    act.sa_handler = litespeed_cleanup;
1207    if( sigaction( SIGTERM, &act, &old_term ) ||
1208        sigaction( SIGINT,  &act, &old_int  ) ||
1209        sigaction( SIGUSR1, &act, &old_usr1 ) ||
1210        sigaction( SIGQUIT, &act, &old_quit )) {
1211        perror( "Can't set signals" );
1212        exit( 1 );
1213    }
1214    s_stop = 0;
1215    while( 1 ) {
1216        while((!s_stop )&&( running < children )) {
1217            pid = fork();
1218            switch( pid ) {
1219            case 0: /* children process */
1220
1221                /* don't catch our signals */
1222                sigaction( SIGTERM, &old_term, 0 );
1223                sigaction( SIGQUIT, &old_quit, 0 );
1224                sigaction( SIGINT,  &old_int,  0 );
1225                sigaction( SIGUSR1, &old_usr1, 0 );
1226                return ;
1227            case -1:
1228                perror( "php (pre-forking)" );
1229                exit( 1 );
1230                break;
1231            default: /* parent process */
1232                running++;
1233                break;
1234            }
1235        }
1236        if ( s_stop ) {
1237            break;
1238        }
1239        pid = wait( &status );
1240        running--;
1241    }
1242    kill( -getpgrp(), SIGUSR1 );
1243    exit( 0 );
1244}
1245
1246void setArgv0( int argc, char * argv[] )
1247{
1248    char * p;
1249    int i;
1250    argv0 = argv[0] + strlen( argv[0] );
1251    p = argv0;
1252    while(( p > argv[0] )&&( p[-1] != '/'))
1253        --p;
1254    if ( p > argv[0] )
1255    {
1256        memmove( argv[0], p, argv0 - p );
1257        memset( argv[0] + ( argv0 - p ), 0, p - argv[0] );
1258        argv0 = argv[0] + (argv0 - p);
1259    }
1260    for( i = 1; i < argc; ++i )
1261    {
1262        memset( argv[i], 0, strlen( argv[i] ) );
1263    }
1264}
1265
1266#include <fcntl.h>
1267int main( int argc, char * argv[] )
1268{
1269    int ret;
1270    int bindFd;
1271
1272    char * php_ini_path = NULL;
1273    char * php_bind     = NULL;
1274    int n;
1275    int climode = 0;
1276    struct timeval tv_req_begin;
1277    struct timeval tv_req_end;
1278    int slow_script_msec = 0;
1279    char time_buf[40];
1280
1281#ifdef HAVE_SIGNAL_H
1282#if defined(SIGPIPE) && defined(SIG_IGN)
1283    signal(SIGPIPE, SIG_IGN);
1284#endif
1285#endif
1286
1287#ifdef ZTS
1288    tsrm_startup(1, 1, 0, NULL);
1289#endif
1290
1291#ifdef ZEND_SIGNALS
1292        zend_signal_startup();
1293#endif
1294
1295    if (argc > 1 ) {
1296        if ( parse_opt( argc, argv, &climode,
1297                &php_ini_path, &php_bind ) == -1 ) {
1298            return 1;
1299        }
1300    }
1301    if ( climode ) {
1302        lsapi_sapi_module.phpinfo_as_text = 1;
1303    } else {
1304        setArgv0(argc, argv );
1305    }
1306
1307    sapi_startup(&lsapi_sapi_module);
1308
1309#ifdef ZTS
1310    compiler_globals = ts_resource(compiler_globals_id);
1311    executor_globals = ts_resource(executor_globals_id);
1312    core_globals = ts_resource(core_globals_id);
1313    sapi_globals = ts_resource(sapi_globals_id);
1314    tsrm_ls = ts_resource(0);
1315
1316    SG(request_info).path_translated = NULL;
1317#endif
1318
1319    lsapi_sapi_module.executable_location = argv[0];
1320
1321    /* Initialize from environment variables before processing command-line
1322     * options: the latter override the former.
1323     */
1324    init_sapi_from_env(&lsapi_sapi_module);
1325   
1326    if ( ignore_php_ini )
1327        lsapi_sapi_module.php_ini_ignore = 1;
1328
1329    if ( php_ini_path ) {
1330        lsapi_sapi_module.php_ini_path_override = php_ini_path;
1331    }
1332
1333
1334    lsapi_sapi_module.ini_defaults = sapi_lsapi_ini_defaults;
1335
1336    if (php_module_startup(&lsapi_sapi_module, &litespeed_module_entry, 1) == FAILURE) {
1337#ifdef ZTS
1338        tsrm_shutdown();
1339#endif
1340        return FAILURE;
1341    }
1342
1343    if ( climode ) {
1344        return cli_main(argc, argv);
1345    }
1346
1347    if ( php_bind ) {
1348        bindFd = LSAPI_CreateListenSock( php_bind, 10 );
1349        if ( bindFd == -1 ) {
1350            fprintf( stderr,
1351                     "Failed to bind socket [%s]: %s\n", php_bind, strerror( errno ) );
1352            exit( 2 );
1353        }
1354        if ( bindFd != 0 ) {
1355            dup2( bindFd, 0 );
1356            close( bindFd );
1357        }
1358    }
1359
1360    LSAPI_Init();
1361
1362    LSAPI_Init_Env_Parameters( NULL );
1363    lsapi_mode = 1;
1364
1365    slow_script_msec = LSAPI_Get_Slow_Req_Msecs();
1366
1367    if ( php_bind ) {
1368        LSAPI_No_Check_ppid();
1369        free( php_bind );
1370        php_bind = NULL;
1371    }
1372
1373    while( LSAPI_Prefork_Accept_r( &g_req ) >= 0 ) {
1374        if ( slow_script_msec ) {
1375            gettimeofday( &tv_req_begin, NULL );
1376        }
1377        ret = processReq();
1378        if ( slow_script_msec ) {
1379            gettimeofday( &tv_req_end, NULL );
1380            n = ((long) tv_req_end.tv_sec - tv_req_begin.tv_sec ) * 1000
1381                + (tv_req_end.tv_usec - tv_req_begin.tv_usec) / 1000;
1382            if ( n > slow_script_msec )
1383            {
1384                strftime( time_buf, 30, "%d/%b/%Y:%H:%M:%S", localtime( &tv_req_end.tv_sec ) );
1385                fprintf( stderr, "[%s] Slow PHP script: %d ms\n  URL: %s %s\n  Query String: %s\n  Script: %s\n",
1386                         time_buf, n,  LSAPI_GetRequestMethod(),
1387                         LSAPI_GetScriptName(), LSAPI_GetQueryString(),
1388                         LSAPI_GetScriptFileName() );
1389
1390            }
1391        }
1392        LSAPI_Finish();
1393        if ( ret ) {
1394            break;
1395        }
1396    }
1397    php_module_shutdown();
1398
1399#ifdef ZTS
1400    tsrm_shutdown();
1401#endif
1402    return ret;
1403}
1404
1405
1406/*   LiteSpeed PHP module starts here */
1407
1408#if PHP_MAJOR_VERSION > 4
1409
1410/* {{{ arginfo */
1411ZEND_BEGIN_ARG_INFO(arginfo_litespeed__void, 0)
1412ZEND_END_ARG_INFO()
1413/* }}} */
1414
1415#else
1416#define arginfo_litespeed__void NULL
1417#endif
1418
1419PHP_FUNCTION(litespeed_request_headers);
1420PHP_FUNCTION(litespeed_response_headers);
1421PHP_FUNCTION(apache_get_modules);
1422
1423PHP_MINFO_FUNCTION(litespeed);
1424
1425
1426zend_function_entry litespeed_functions[] = {
1427    PHP_FE(litespeed_request_headers,   arginfo_litespeed__void)
1428    PHP_FE(litespeed_response_headers,  arginfo_litespeed__void)
1429    PHP_FE(apache_get_modules,          arginfo_litespeed__void)
1430    PHP_FALIAS(getallheaders,           litespeed_request_headers,  arginfo_litespeed__void)
1431    PHP_FALIAS(apache_request_headers,  litespeed_request_headers,  arginfo_litespeed__void)
1432    PHP_FALIAS(apache_response_headers, litespeed_response_headers, arginfo_litespeed__void)
1433    {NULL, NULL, NULL}
1434};
1435
1436static PHP_MINIT_FUNCTION(litespeed)
1437{
1438    user_config_cache_init();
1439
1440    const char *p = getenv("LSPHP_ENABLE_USER_INI");
1441    if (p && 0 == strcasecmp(p, "on"))
1442        parse_user_ini = 1;
1443
1444    /* REGISTER_INI_ENTRIES(); */
1445    return SUCCESS;
1446}
1447
1448
1449static PHP_MSHUTDOWN_FUNCTION(litespeed)
1450{
1451    zend_hash_destroy(&user_config_cache);
1452
1453    /* UNREGISTER_INI_ENTRIES(); */
1454    return SUCCESS;
1455}
1456
1457zend_module_entry litespeed_module_entry = {
1458    STANDARD_MODULE_HEADER,
1459    "litespeed",
1460    litespeed_functions,
1461    PHP_MINIT(litespeed),
1462    PHP_MSHUTDOWN(litespeed),
1463    NULL,
1464    NULL,
1465    NULL,
1466    NO_VERSION_YET,
1467    STANDARD_MODULE_PROPERTIES
1468};
1469
1470static int add_associate_array( const char * pKey, int keyLen, const char * pValue, int valLen,
1471                         void * arg )
1472{
1473    add_assoc_string_ex((zval *)arg, (char *)pKey, keyLen, (char *)pValue);
1474    return 1;
1475}
1476
1477
1478/* {{{ proto array litespeed_request_headers(void)
1479   Fetch all HTTP request headers */
1480PHP_FUNCTION(litespeed_request_headers)
1481{
1482    /* TODO: */
1483    if (ZEND_NUM_ARGS() > 0) {
1484        WRONG_PARAM_COUNT;
1485    }
1486    array_init(return_value);
1487
1488    LSAPI_ForeachOrgHeader( add_associate_array, return_value );
1489
1490}
1491/* }}} */
1492
1493
1494
1495/* {{{ proto array litespeed_response_headers(void)
1496   Fetch all HTTP response headers */
1497PHP_FUNCTION(litespeed_response_headers)
1498{
1499    sapi_header_struct  *h;
1500    zend_llist_position pos;
1501    char *       p;
1502    int          len;
1503    char         headerBuf[SAPI_LSAPI_MAX_HEADER_LENGTH];
1504
1505    if (ZEND_NUM_ARGS() > 0) {
1506        WRONG_PARAM_COUNT;
1507    }
1508
1509    if (!&SG(sapi_headers).headers) {
1510        RETURN_FALSE;
1511    }
1512    array_init(return_value);
1513
1514    h = zend_llist_get_first_ex(&SG(sapi_headers).headers, &pos);
1515    while (h) {
1516        if ( h->header_len > 0 ) {
1517            p = strchr( h->header, ':' );
1518            len = p - h->header;
1519            if (( p )&&( len > 0 )) {
1520                memmove( headerBuf, h->header, len );
1521                while( len > 0 && (isspace( headerBuf[len-1])) ) {
1522                    --len;
1523                }
1524                headerBuf[len] = 0;
1525                if ( len ) {
1526                    while( isspace(*++p));
1527                    add_assoc_string_ex(return_value, headerBuf, len, p);
1528                }
1529            }
1530        }
1531        h = zend_llist_get_next_ex(&SG(sapi_headers).headers, &pos);
1532    }
1533}
1534
1535/* }}} */
1536
1537
1538/* {{{ proto array apache_get_modules(void)
1539   Fetch all loaded module names  */
1540PHP_FUNCTION(apache_get_modules)
1541{
1542    static const char * mod_names[] =
1543    {
1544        "mod_rewrite", "mod_mime", "mod_headers", "mod_expires", "mod_auth_basic", NULL
1545    };
1546    const char **name = mod_names;
1547    /* TODO: */
1548    if (ZEND_NUM_ARGS() > 0) {
1549        WRONG_PARAM_COUNT;
1550    }
1551    array_init(return_value);
1552    while( *name )
1553    {
1554        add_next_index_string(return_value, *name
1555#if PHP_MAJOR_VERSION < 7
1556                                        , 1
1557#endif
1558        );
1559        ++name;
1560    }
1561}
1562/* }}} */
1563
1564
1565/*
1566 * Local variables:
1567 * tab-width: 4
1568 * c-basic-offset: 4
1569 * End:
1570 * vim600: sw=4 ts=4 fdm=marker
1571 * vim<600: sw=4 ts=4
1572 */
1573
1574
Note: See TracBrowser for help on using the repository browser.