path: root/sapi/litespeed/lsapi_main.c

/*
   +----------------------------------------------------------------------+
   | PHP Version 4                                                        |
   +----------------------------------------------------------------------+
   | Copyright (c) 1997-2005 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.02 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available at through the world-wide-web at                           |
   | http://www.php.net/license/2_02.txt.                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Author: George Wang <gwang@litespeedtech.com>                        |
   +----------------------------------------------------------------------+
*/


#include "php.h"
#include "SAPI.h"
#include "php_main.h"
#include "php_ini.h"
#include "php_variables.h"
#include "zend_highlight.h"

#include "lsapilib.h"

#include <stdio.h>
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef PHP_WIN32
#include <io.h>
#include <fcntl.h>
#include "win32/php_registry.h"
#else
#include <sys/wait.h>
#endif
#include <sys/stat.h>

#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if HAVE_SIGNAL_H
#include <signal.h>
#endif

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>


#define SAPI_LSAPI_MAX_HEADER_LENGTH 2048
static char s_headerBuf[SAPI_LSAPI_MAX_HEADER_LENGTH];

static int  lsapi_mode       = 1;
static char *php_self        = "";
static char *script_filename = "";

#ifdef ZTS
zend_compiler_globals    *compiler_globals;
zend_executor_globals    *executor_globals;
php_core_globals         *core_globals;
sapi_globals_struct      *sapi_globals;
void ***tsrm_ls;
#endif


/* {{{ php_lsapi_startup
 */
static int php_lsapi_startup(sapi_module_struct *sapi_module)
{
    if (php_module_startup(sapi_module, NULL, 0)==FAILURE) {
        return FAILURE;
    }
    return SUCCESS;
}
/* }}} */



/* {{{ sapi_lsapi_ub_write
 */
static int sapi_lsapi_ub_write(const char *str, uint str_length TSRMLS_DC)
{
    int ret;
    int remain;
    if ( lsapi_mode )
    {
        ret  = LSAPI_Write( str, str_length );
        if ( ret < str_length )
        {
            php_handle_aborted_connection();
            return str_length - ret;
        }
    }
    else
    {
        remain = str_length;
        while( remain > 0 )
        {
            ret = write( 1, str, remain );
            if ( ret <= 0 )
            {
                php_handle_aborted_connection();
                return str_length - remain;
            }
            str += ret;
            remain -= ret;
        }
    }
    return str_length;
}
/* }}} */


/* {{{ sapi_lsapi_flush
 */
static void sapi_lsapi_flush( void * server_context )
{
    if ( lsapi_mode )
    {
        if ( LSAPI_Flush() == -1)
            php_handle_aborted_connection();
    }
}
/* }}} */


/* {{{ sapi_lsapi_deactivate
 */
static int sapi_lsapi_deactivate(TSRMLS_D)
{
    LSAPI_Finish();
    return SUCCESS;
}
/* }}} */




/* {{{ sapi_lsapi_getenv
 */
static char *sapi_lsapi_getenv( char * name, size_t name_len TSRMLS_DC )
{
    if ( lsapi_mode )
        return LSAPI_GetEnv( name );
    else
        return getenv( name );
}
/* }}} */



static int add_variable( const char * pKey, int keyLen, const char * pValue, int valLen,
                         void * arg )
{
    php_register_variable_safe((char *)pKey, (char *)pValue, valLen, (zval *)arg TSRMLS_CC);
    return 1;
}



/* {{{ sapi_lsapi_register_variables
 */
static void sapi_lsapi_register_variables(zval *track_vars_array TSRMLS_DC)
{

    if ( lsapi_mode )
    {
        LSAPI_ForeachHeader( add_variable, track_vars_array );
        LSAPI_ForeachEnv( add_variable, track_vars_array );
        php_import_environment_variables(track_vars_array TSRMLS_CC);

        php_register_variable("PHP_SELF", (SG(request_info).request_uri ? SG(request_info).request_uri:""), track_vars_array TSRMLS_CC);
    }
    else
    {
        php_import_environment_variables(track_vars_array TSRMLS_CC);

        php_register_variable("PHP_SELF", php_self, track_vars_array TSRMLS_CC);
        php_register_variable("SCRIPT_NAME", php_self, track_vars_array TSRMLS_CC);
        php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array TSRMLS_CC);
        php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array TSRMLS_CC);
        php_register_variable("DOCUMENT_ROOT", "", track_vars_array TSRMLS_CC);

    }
}
/* }}} */


/* {{{ sapi_lsapi_read_post
 */
static int sapi_lsapi_read_post(char *buffer, uint count_bytes TSRMLS_DC)
{
    if ( lsapi_mode )
    {
        return LSAPI_ReadReqBody( buffer, count_bytes );
    }
    else
        return 0;
}
/* }}} */




/* {{{ sapi_lsapi_read_cookies
 */
static char *sapi_lsapi_read_cookies(TSRMLS_D)
{
    if ( lsapi_mode )
        return LSAPI_GetHeader( H_COOKIE );
    else
        return NULL;
}
/* }}} */


/* {{{ sapi_lsapi_send_headers
 */
static int sapi_lsapi_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
{
    sapi_header_struct  *h;
    zend_llist_position pos;
    if ( lsapi_mode )
    {
        LSAPI_SetRespStatus( SG(sapi_headers).http_response_code );

        h = zend_llist_get_first_ex(&sapi_headers->headers, &pos);
        while (h) {
            LSAPI_AppendRespHeader(h->header, h->header_len);
            h = zend_llist_get_next_ex(&sapi_headers->headers, &pos);
        }
        if (SG(sapi_headers).send_default_content_type)
        {
            char    *hd;
            int     len;

            hd = sapi_get_default_content_type(TSRMLS_C);
            len = snprintf( s_headerBuf, SAPI_LSAPI_MAX_HEADER_LENGTH - 1,
                            "Content-type: %s", hd );
            efree(hd);

            LSAPI_AppendRespHeader( s_headerBuf, len );
        }
    }
    LSAPI_FinalizeRespHeaders();
    return SAPI_HEADER_SENT_SUCCESSFULLY;


}
/* }}} */


/* {{{ sapi_lsapi_send_headers
 */
static void sapi_lsapi_log_message(char *message)
{
    int len = strlen( message );
    LSAPI_Write_Stderr( message, len);
}
/* }}} */


/* {{{ sapi_module_struct cgi_sapi_module
 */
static sapi_module_struct lsapi_sapi_module =
{
    "litespeed",
    "LiteSpeed",

    php_lsapi_startup,              /* startup */
    php_module_shutdown_wrapper,    /* shutdown */

    NULL,                           /* activate */
    sapi_lsapi_deactivate,          /* deactivate */

    sapi_lsapi_ub_write,            /* unbuffered write */
    sapi_lsapi_flush,               /* flush */
    NULL,                           /* get uid */
    sapi_lsapi_getenv,              /* getenv */

    php_error,                      /* error handler */

    NULL,                           /* header handler */
    sapi_lsapi_send_headers,        /* send headers handler */
    NULL,                           /* send header handler */

    sapi_lsapi_read_post,           /* read POST data */
    sapi_lsapi_read_cookies,        /* read Cookies */

    sapi_lsapi_register_variables,  /* register server variables */
    sapi_lsapi_log_message,         /* Log message */

    NULL,                           /* php.ini path override */
    NULL,                           /* block interruptions */
    NULL,                           /* unblock interruptions */
    NULL,                           /* default post reader */
    NULL,                           /* treat data */
    NULL,                           /* executable location */

    0,                              /* php.ini ignore */

    STANDARD_SAPI_MODULE_PROPERTIES

};
/* }}} */

static int init_request_info( TSRMLS_D )
{
    char * pContentType = LSAPI_GetHeader( H_CONTENT_TYPE );
    char * pAuth;
    
    SG(request_info).content_type = pContentType ? pContentType : "";
    SG(request_info).request_method = LSAPI_GetRequestMethod();
    SG(request_info).query_string = LSAPI_GetQueryString();
    SG(request_info).request_uri = LSAPI_GetScriptName();
    SG(request_info).content_length = LSAPI_GetReqBodyLen();
    SG(request_info).path_translated = LSAPI_GetScriptFileName();
    SG(sapi_headers).http_response_code = 0;    //It is not reset by zend engine, set it to 0.
    
    pAuth = LSAPI_GetHeader( H_AUTHORIZATION );
    php_handle_auth_data(pAuth TSRMLS_CC);
}

static int lsapi_module_main(int show_source TSRMLS_DC)
{
    zend_file_handle file_handle = {0};

    if (php_request_startup(TSRMLS_C) == FAILURE )
        return -1;
    if (show_source)
    {
        zend_syntax_highlighter_ini syntax_highlighter_ini;

        php_get_highlight_struct(&syntax_highlighter_ini);
        highlight_file(SG(request_info).path_translated, &syntax_highlighter_ini TSRMLS_CC);
    }
    else
    {
        file_handle.type = ZEND_HANDLE_FILENAME;
        file_handle.handle.fd = 0;
        file_handle.filename = SG(request_info).path_translated;
        file_handle.free_filename = 0;
        file_handle.opened_path = NULL;

        php_execute_script(&file_handle TSRMLS_CC);
    }
    zend_try
    {
        php_request_shutdown(NULL);
    } zend_end_try();
    return 0;
}


static int alter_ini( const char * pKey, int keyLen, const char * pValue, int valLen,
                void * arg )
{
    int type = ZEND_INI_PERDIR;
    if ( '\001' == *pKey )
    {
        ++pKey;
        if ( *pKey == 4 )
            type = ZEND_INI_SYSTEM;
        ++pKey;
        --keyLen;
        zend_alter_ini_entry((char *)pKey, keyLen,
                             (char *)pValue, valLen,
                             type, PHP_INI_STAGE_ACTIVATE);
    }
    return 1;
}


static void override_ini()
{

    LSAPI_ForeachSpecialEnv( alter_ini, NULL );

}

static int processReq( TSRMLS_D )
{
    int ret = 0;
    zend_first_try
    {
        /* avoid server_context==NULL checks */
        SG(server_context) = (void *) 1;

        init_request_info( TSRMLS_C );

        override_ini();

        if ( lsapi_module_main( 0 TSRMLS_CC ) == -1 )
            ret = -1;

    } zend_end_try();
    return ret;
}

static void cli_usage( TSRMLS_D )
{
    static const char * usage =
        "Usage: php\n"
        "       php -[h|i|q|v|?] [<file>] [args...]\n"
        "  Run in LSAPI mode when no parameter or only '-c' is specified\n"
        "  Run in Command Line Interpreter mode when parameters are specified"
        "\n"
        "  -c <path>|<file> Look for php.ini file in this directory\n"
        "  -h               This help\n"
        "  -i               PHP information\n"
        "  -q               Quiet-mode.  Suppress HTTP Header output.\n"
        "  -v               Version number\n"
        "  -?               This help\n"
        "\n"
        "  args...          Arguments passed to script.\n";
    php_output_startup();
    php_output_activate(TSRMLS_C);
//    SG(headers_sent) = 1;
    php_printf( usage );
    php_end_ob_buffers(1 TSRMLS_CC);
}

static int parse_opt( int argc, char * argv[], int *climode,
                        char **php_ini_path )
{
    char ** p = &argv[1];
    char ** argend= &argv[argc];
    int c;
    while (( p < argend )&&(**p == '-' ))
    {
        c = *((*p)+1);
        ++p;
        switch( c )
        {
        case 'c':
            if ( p >= argend )
            {
                fprintf( stderr, "<path> or <file> must be specified following '-c' option.\n");

                return -1;
            }
            *php_ini_path = *p++;
            break;
        case 'h':
        case 'i':
        case 'q':
        case 'v':
        case '?':
        default:
            *climode = 1;
            break;
        }
    }
    if ( p - argv < argc )
        *climode = 1;
    return 0;
}

static int cli_main( int argc, char * argv[] )
{

    static const char * ini_defaults[] =
    {
        "report_zend_debug",    "0",
        "display_errors",        "1",
        "register_argc_argv",    "1",
        "html_errors",            "0",
        "implicit_flush",        "1",
        "output_buffering",        "0",
        "max_execution_time",    "0",
        NULL
    };

    const char ** ini;
    char ** p = &argv[1];
    char ** argend= &argv[argc];
    int ret = 0;
    int c;
    lsapi_mode = 0;            /* enter CLI mode */

#ifdef PHP_WIN32
    _fmode = _O_BINARY;            /*sets default for file streams to binary */
    setmode(_fileno(stdin), O_BINARY);        /* make the stdio mode be binary */
    setmode(_fileno(stdout), O_BINARY);        /* make the stdio mode be binary */
    setmode(_fileno(stderr), O_BINARY);        /* make the stdio mode be binary */
#endif

    zend_first_try
    {
        SG(server_context) = (void *) 1;

        zend_uv.html_errors = 0; /* tell the engine we're in non-html mode */
        CG(in_compilation) = 0; /* not initialized but needed for several options */
        EG(uninitialized_zval_ptr) = NULL;

        for( ini = ini_defaults; *ini; ini+=2 )
        {
            zend_alter_ini_entry( (char *)*ini, strlen( *ini )+1,
                                (char *)*(ini+1), strlen( *(ini+1) ),
                                PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
        }

        while (( p < argend )&&(**p == '-' ))
        {
            c = *((*p)+1);
            ++p;
            switch( c )
            {
            case 'q':
//                SG(headers_sent) = 1;
//                SG(request_info).no_headers = 1;
                break;
            case 'i':
                if (php_request_startup(TSRMLS_C) != FAILURE)
                {
//                    SG(headers_sent) = 1;
//                    SG(request_info).no_headers = 1;
                    php_print_info(0xFFFFFFFF TSRMLS_CC);
                    php_end_ob_buffers(1 TSRMLS_CC);
                    php_request_shutdown( NULL );
                }
                ret = 1;
                break;
            case 'v':
                if (php_request_startup(TSRMLS_C) != FAILURE)
                {
//                    SG(headers_sent) = 1;
//                    SG(request_info).no_headers = 1;
#if ZEND_DEBUG
                    php_printf("PHP %s (%s) (built: %s %s) (DEBUG)\nCopyright (c) 1997-2004 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
#else
                    php_printf("PHP %s (%s) (built: %s %s)\nCopyright (c) 1997-2004 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
#endif
                    php_end_ob_buffers(1 TSRMLS_CC);
                    php_request_shutdown( NULL );
                }
                ret = 1;
                break;
            case 'c':
                ++p;
                break;
            case 'h':
            case '?':
            default:
                cli_usage(TSRMLS_C);
                ret = 1;
                break;

            }
        }
        if ( !ret )
        {
            if ( *p )
            {
                zend_file_handle file_handle = {0};

                file_handle.type = ZEND_HANDLE_FP;
                file_handle.handle.fp = VCWD_FOPEN(*p, "rb");

                if ( file_handle.handle.fp )
                {
                    script_filename = *p;
                    php_self = *p;

                    SG(request_info).path_translated = *p;
                    SG(request_info).argc = argc - (p - argv);
                    SG(request_info).argv = p;

                    if (php_request_startup(TSRMLS_C) == FAILURE )
                    {
                        fclose( file_handle.handle.fp );
                        ret = 2;
                    }
                    else
                    {

                        file_handle.filename = *p;
                        file_handle.free_filename = 0;
                        file_handle.opened_path = NULL;

                        php_execute_script(&file_handle TSRMLS_CC);
                        php_request_shutdown( NULL );
                    }
                }
                else
                {
                    php_printf("Could not open input file: %s.\n", *p);
                }
            }
            else
            {
                cli_usage(TSRMLS_C);
            }
        }

    }zend_end_try();

    php_module_shutdown(TSRMLS_C);

#ifdef ZTS
    tsrm_shutdown();
#endif
    return ret;
}

static int s_stop;
void litespeed_cleanup(int signal)
{
    s_stop = signal;
}


void start_children( int children )
{
    struct sigaction act, old_term, old_quit, old_int, old_usr1;
    int running = 0;
    int status;
    pid_t pid;

    /* Create a process group */
    setsid();

    /* Set up handler to kill children upon exit */
    act.sa_flags = 0;
    act.sa_handler = litespeed_cleanup;
    if( sigaction( SIGTERM, &act, &old_term ) ||
        sigaction( SIGINT,  &act, &old_int  ) ||
        sigaction( SIGUSR1, &act, &old_usr1 ) ||
        sigaction( SIGQUIT, &act, &old_quit ))
    {
        perror( "Can't set signals" );
        exit( 1 );
    }
    s_stop = 0;
    while( 1 )
    {
        while((!s_stop )&&( running < children ))
        {
            pid = fork();
            switch( pid ) {
            case 0: /* children process */

                /* don't catch our signals */
                sigaction( SIGTERM, &old_term, 0 );
                sigaction( SIGQUIT, &old_quit, 0 );
                sigaction( SIGINT,  &old_int,  0 );
                sigaction( SIGUSR1, &old_usr1, 0 );
                return ;
            case -1:
                perror( "php (pre-forking)" );
                exit( 1 );
                break;
            default: /* parent process */
                running++;
                break;
            }
        } 
        if ( s_stop )
            break;
        pid = wait( &status );
        running--;
    }
	kill( -getpgrp(), s_stop );
    exit( 0 );
}



#include <fcntl.h>
int main( int argc, char * argv[] )
{
    int ret;
    int max_requests = 500;
    int requests     = 0;

    char * php_ini_path = NULL;
    int climode = 0;

#ifdef HAVE_SIGNAL_H
#if defined(SIGPIPE) && defined(SIG_IGN)
    signal(SIGPIPE, SIG_IGN);
#endif
#endif

#ifdef ZTS
    tsrm_startup(1, 1, 0, NULL);
#endif

    if (argc > 1 )
    {
        if ( parse_opt( argc, argv, &climode, &php_ini_path ) == -1 )
            return 1;
    }
    if ( climode )
        lsapi_sapi_module.phpinfo_as_text = 1;
    sapi_startup(&lsapi_sapi_module);

#ifdef ZTS
    compiler_globals = ts_resource(compiler_globals_id);
    executor_globals = ts_resource(executor_globals_id);
    core_globals = ts_resource(core_globals_id);
    sapi_globals = ts_resource(sapi_globals_id);
    tsrm_ls = ts_resource(0);

    SG(request_info).path_translated = NULL;
#endif

    lsapi_sapi_module.executable_location = argv[0];

    if ( php_ini_path )
        lsapi_sapi_module.php_ini_path_override = php_ini_path;

    if (php_module_startup(&lsapi_sapi_module, NULL, 0) == FAILURE) {
#ifdef ZTS
        tsrm_shutdown();
#endif
        return FAILURE;
    }

    if ( climode )
    {
        return cli_main(argc, argv);
    }

    if( getenv( "PHP_LSAPI_MAX_REQUESTS" ))
    {
        max_requests = atoi( getenv( "PHP_LSAPI_MAX_REQUESTS" ));
        if( !max_requests )
        {
            fprintf( stderr,
                     "PHP_LSAPI_MAX_REQUESTS is not valid\n" );
            exit( 1 );
        }
    }
    
    LSAPI_Init();

    if (( getenv( "PHP_LSAPI_CHILDREN" ) )&& LSAPI_Is_Listen() )
    {
        int children = atoi( getenv( "PHP_LSAPI_CHILDREN" ));
        if ( children > 0 )
            start_children( children );
    }

    while( LSAPI_Accept() >= 0 )
    {
        ret = processReq(TSRMLS_C);
        LSAPI_Finish();
        if ( ret )
            break;
        requests++;
        if( max_requests && ( requests == max_requests ))
        {
            break;
        }
    }
    php_module_shutdown(TSRMLS_C);

#ifdef ZTS
    tsrm_shutdown();
#endif
    return ret;
}

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: sw=4 ts=4 fdm=marker
 * vim<600: sw=4 ts=4
 */