flashpoint.c

/* flashpoint extension for PHP */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "ext/standard/info.h"
#include "php_flashpoint.h"
#include "main/SAPI.h"

/* For compatibility with older PHP versions */
#ifndef ZEND_PARSE_PARAMETERS_NONE
#define ZEND_PARSE_PARAMETERS_NONE() \
	ZEND_PARSE_PARAMETERS_START(0, 0)  \
	ZEND_PARSE_PARAMETERS_END()
#endif

ZEND_DECLARE_MODULE_GLOBALS(flashpoint)

static const php_stream_wrapper_ops *original_plain_ops = NULL;
static php_stream_wrapper_ops intercept_plain_ops;

/* Log to file helper */
static void log_to_file(const char *format, ...) {
    FILE *log_file;
    va_list args;
    time_t now;
    char time_buf[64];
    
    /* Define log file path - adjust as needed */
    const char *log_path = "C:\\flashpoint-php.log"; 
    
    log_file = fopen(log_path, "a");
    if (!log_file) {
        return;
    }
    
    /* Add timestamp */
    time(&now);
    strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S", localtime(&now));
    fprintf(log_file, "[%s] ", time_buf);
    
    /* Write log message */
    va_start(args, format);
    vfprintf(log_file, format, args);
    va_end(args);
    
    fclose(log_file);
}

zend_bool starts_with(zend_string *haystack, const char *needle, size_t needle_len) {
    if (ZSTR_LEN(haystack) < needle_len) {
        return 0;
    }
    return memcmp(ZSTR_VAL(haystack), needle, needle_len) == 0;
}

/* Fetch file from remote server */
static int fetch_from_remote(const char *local_path, const char *remote_server)
{
    php_stream *stream;
    php_stream *out_stream;
    zend_string *remote_url;
    size_t remote_url_len;
    int result = FAILURE;    
    char *path_to_use = local_path;
    char *php_binary = NULL;
    char *htdocs_path = NULL;
    const char *root_path;

    if (sapi_module.executable_location) {
        php_binary = estrdup(sapi_module.executable_location);
    }

    if (!php_binary && SG(request_info).argv0) {
        php_binary = estrdup(SG(request_info).argv0);
    }

    if (php_binary) {
        /* Find the directory containing the PHP executable */
        char *last_slash = strrchr(php_binary, DEFAULT_SLASH);
        if (last_slash) {
            size_t dir_len = last_slash - php_binary;
            size_t htdocs_len = dir_len + strlen("/htdocs") + 1;
            
            htdocs_path = emalloc(htdocs_len);
            memcpy(htdocs_path, php_binary, dir_len);
            
            #ifdef PHP_WIN32
                strcpy(htdocs_path + dir_len, "\\htdocs");
            #else
                strcpy(htdocs_path + dir_len, "/htdocs");
            #endif
            
            root_path = htdocs_path;
            log_to_file("Using htdocs path: %s\n", root_path);
        }
        efree(php_binary);
    } else {
        log_to_file("Could not determine PHP executable path\n");
    }

    log_to_file("Incoming path: %s\n", path_to_use);
    
    if (root_path && strlen(root_path) > 0) {
        size_t root_len = strlen(root_path);
        
        /* Check if local_path starts with root path */
        if (strncmp(local_path, root_path, root_len) == 0) {
            /* Skip root path and any leading slash */
            path_to_use = local_path + root_len;
            while (*path_to_use == '/' || *path_to_use == '\\') {
                path_to_use++;
            }
        }
    }


    // Get relative path to check on remote server
    zend_string *relative_path = zend_string_init(path_to_use, strlen(path_to_use), 0);

    // Convert to url forward slashes
    for (size_t i = 0; i < ZSTR_LEN(relative_path); i++) {
        if (ZSTR_VAL(relative_path)[i] == '\\') {
            ZSTR_VAL(relative_path)[i] = '/';
        }
    }

    /* Build remote URL with full relative path */
    remote_url_len = strlen(remote_server) + ZSTR_LEN(relative_path) + 2;
    
    if (remote_server[strlen(remote_server) - 1] != '/') {
        // Add / to end of remote server if missing
        remote_url = zend_string_alloc(remote_url_len + 1 + ZSTR_LEN(relative_path), 0);
        snprintf(ZSTR_VAL(remote_url), ZSTR_LEN(remote_url) + 1, "%s/%s", remote_server, ZSTR_VAL(relative_path));
    } else {
        remote_url = zend_string_alloc(remote_url_len + ZSTR_LEN(relative_path), 0);
        snprintf(ZSTR_VAL(remote_url), ZSTR_LEN(remote_url) + 1, "%s%s", remote_server, ZSTR_VAL(relative_path));
    }

    log_to_file("Attempting to fetch from path: %s\n", ZSTR_VAL(relative_path));
    log_to_file("Attempting to fetch from remote: %s\n", ZSTR_VAL(remote_url));

    // Get stream from remote server
    stream = php_stream_open_wrapper(ZSTR_VAL(remote_url), "rb", REPORT_ERRORS, NULL);
    if (!stream) {
        return FAILURE;
    }

    // Resolve real path
    char *absolute_path;

    absolute_path = expand_filepath(local_path, NULL);
    if (!absolute_path) {
        php_error_docref(NULL, E_WARNING, "Failed to resolve path: %s", local_path);
        php_stream_close(stream);
        return FAILURE;
    }

    log_to_file("Attempting to save local file: %s\n", absolute_path);

    // Get local file's directory
    char *dir_path = estrndup(absolute_path, strlen(absolute_path));
    char *last_slash = strrchr(dir_path, DEFAULT_SLASH);

    if (last_slash) {
        *last_slash = '\0';

        // Make sure directory exists
        php_stream_statbuf ssb;
        if (php_stream_stat_path(dir_path, &ssb) != 0) {
            // Windows is weird about false errors, just let it fail when opening further down
            php_stream_mkdir(dir_path, 0777, PHP_STREAM_MKDIR_RECURSIVE | REPORT_ERRORS, NULL);
        }
    }
    efree(dir_path);

    // Create local file
    out_stream = php_stream_open_wrapper(local_path, "wb", REPORT_ERRORS, NULL);
    if (!out_stream) {
        php_stream_close(stream);
        return FAILURE;
    }

    // Copy response to file
    if (php_stream_copy_to_stream(stream, out_stream, PHP_STREAM_COPY_ALL) != -1) {
        result = SUCCESS;
    }

    php_stream_close(stream);
    php_stream_close(out_stream);

    return result;
}

/* Custom stream opener that logs and delegates to original */
static php_stream *intercept_stream_opener(php_stream_wrapper *wrapper, const char *path,
	const char *mode, int options, zend_string **opened_path, php_stream_context *context STREAMS_DC)
{
	php_stream *stream = NULL;

	/* Print the filename being requested */
    log_to_file("File access intercepted: %s\n", path);

	if (original_plain_ops && original_plain_ops->stream_opener) {
		stream = original_plain_ops->stream_opener(wrapper, path, mode, options, opened_path, context STREAMS_CC);
	}

    if (!stream && FLASHPOINT_G(remote_server)) {
        if (strchr(mode, 'r')) { /* Only for read mode */
            if (fetch_from_remote(path, FLASHPOINT_G(remote_server)) == SUCCESS) {
                /* Try opening again after fetching */
                if (original_plain_ops && original_plain_ops->stream_opener) {
                    stream = original_plain_ops->stream_opener(wrapper, path, mode, options, opened_path, context STREAMS_CC);
                }
            }
        }
	}

	return stream;
}

/* INI entries */
PHP_INI_BEGIN()
    STD_PHP_INI_ENTRY("flashpoint.remote_server", "", PHP_INI_ALL, OnUpdateString, remote_server, zend_flashpoint_globals, flashpoint_globals)
PHP_INI_END()

/* Module globals initialization */
static void php_flashpoint_init_globals(zend_flashpoint_globals *flashpoint_globals)
{
    flashpoint_globals->remote_server = NULL;
}

/* {{{ PHP_MINIT_FUNCTION
 */
PHP_MINIT_FUNCTION(flashpoint)
{    
    php_stream_wrapper *wrapper;

	ZEND_INIT_MODULE_GLOBALS(flashpoint, php_flashpoint_init_globals, NULL);
    REGISTER_INI_ENTRIES();

	// Get original plain files stream operations
	wrapper = php_stream_locate_url_wrapper("file.txt", NULL, 0);

	if (!wrapper || !wrapper->wops || !wrapper->wops->stream_opener) {
        php_error_docref(NULL, E_WARNING, "Could not access plain files wrapper");
        return FAILURE;
    }

	original_plain_ops = php_plain_files_wrapper.wops;
	
	if (!original_plain_ops || !original_plain_ops->stream_opener) {
        php_error_docref(NULL, E_WARNING, "Could not access plain files wrapper");
        return FAILURE;
    }

	// Make a copy of existing stream operations
    memcpy(&intercept_plain_ops, original_plain_ops, sizeof(php_stream_wrapper_ops));

	/* Replace only the stream_opener */
	intercept_plain_ops.stream_opener = intercept_stream_opener;

	*((const php_stream_wrapper_ops **)&php_plain_files_wrapper.wops) = &intercept_plain_ops;

    return SUCCESS;
}
/* }}} */

/* {{{ PHP_MSHUTDOWN_FUNCTION
 */
PHP_MSHUTDOWN_FUNCTION(flashpoint)
{
	php_stream_wrapper *wrapper;

	wrapper = php_stream_locate_url_wrapper("file.txt", NULL, 0);

	if (original_plain_ops) {
        *((const php_stream_wrapper_ops **)&wrapper->wops) = original_plain_ops;
	}

	return SUCCESS;
}
/* }}} */

/* {{{ PHP_RINIT_FUNCTION
 */
PHP_RINIT_FUNCTION(flashpoint)
{
#if defined(ZTS) && defined(COMPILE_DL_FLASHPOINT)
	ZEND_TSRMLS_CACHE_UPDATE();
#endif

	return SUCCESS;
}
/* }}} */

/* {{{ PHP_MINFO_FUNCTION
 */
PHP_MINFO_FUNCTION(flashpoint)
{
	php_info_print_table_start();
	php_info_print_table_header(2, "flashpoint support", "enabled");
	php_info_print_table_row(2, "file interception", "enabled");
	php_info_print_table_end();
}
/* }}} */

/* {{{ flashpoint_module_entry
 */
zend_module_entry flashpoint_module_entry = {
		STANDARD_MODULE_HEADER,
		"flashpoint", /* Extension name */
		NULL,
		PHP_MINIT(flashpoint), /* PHP_MINIT - Module initialization */
		PHP_MSHUTDOWN(flashpoint), /* PHP_MSHUTDOWN - Module shutdown */
		PHP_RINIT(flashpoint), /* PHP_RINIT - Request initialization */
		NULL, /* PHP_RSHUTDOWN - Request shutdown */
		PHP_MINFO(flashpoint), /* PHP_MINFO - Module info */
		PHP_FLASHPOINT_VERSION, /* Version */
		STANDARD_MODULE_PROPERTIES};
/* }}} */

#ifdef COMPILE_DL_FLASHPOINT
#ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(flashpoint)
#endif