/* +----------------------------------------------------------------------+ | PHP Version 5 | +----------------------------------------------------------------------+ | Copyright (c) 1997-2006 The PHP Group | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | | available through the world-wide-web at the following url: | | http://www.php.net/license/3_01.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. | +----------------------------------------------------------------------+ | Authors: Zeev Suraski | | Thies C. Arntzen | | Marcus Boerger | | New API: Michael Wallner | +----------------------------------------------------------------------+ */ /* $Id: output.c,v 1.167.2.3 2006/03/27 08:26:10 tony2001 Exp $ */ #ifndef PHP_OUTPUT_DEBUG # define PHP_OUTPUT_DEBUG 0 #endif #ifndef PHP_OUTPUT_NOINLINE # define PHP_OUTPUT_NOINLINE 0 #endif #include "php.h" #include "ext/standard/head.h" #include "ext/standard/url_scanner_ex.h" #include "SAPI.h" #include "zend_stack.h" #include "php_output.h" ZEND_DECLARE_MODULE_GLOBALS(output); #if PHP_OUTPUT_NOINLINE || PHP_OUTPUT_DEBUG # undef inline # define inline #endif /* {{{ aliases, conflict and reverse conflict hash tables */ static HashTable php_output_handler_aliases; static HashTable php_output_handler_conflicts; static HashTable php_output_handler_reverse_conflicts; /* }}} */ /* {{{ forward declarations */ static inline int php_output_lock_error(int op TSRMLS_DC); static inline void php_output_op(int op, const char *str, size_t len TSRMLS_DC); static inline php_output_handler *php_output_handler_init(const char *name, size_t chunk_size, int flags); static inline int php_output_handler_op(php_output_handler *handler, php_output_context *context); static inline int php_output_handler_append(php_output_handler *handler, const php_output_buffer *buf TSRMLS_DC); static inline zval *php_output_handler_status(php_output_handler *handler, zval *entry); static inline php_output_context *php_output_context_init(php_output_context *context, int op TSRMLS_DC); static inline void php_output_context_reset(php_output_context *context); static inline void php_output_context_swap(php_output_context *context); static inline void php_output_context_dtor(php_output_context *context); static inline int php_output_stack_pop(int discard, int shutdown TSRMLS_DC); static int php_output_stack_apply_op(void *h, void *c); static int php_output_stack_apply_clean(void *h, void *c); static int php_output_stack_apply_list(void *h, void *z); static int php_output_stack_apply_status(void *h, void *z); static int php_output_handler_compat_func(void **handler_context, php_output_context *output_context); static int php_output_handler_default_func(void **handler_context, php_output_context *output_context); static int php_output_handler_devnull_func(void **handler_context, php_output_context *output_context); /* }}} */ /* {{{ static void php_output_init_globals(zend_output_globals *G) Initialize the module globals on MINIT */ static inline void php_output_init_globals(zend_output_globals *G) { memset(G, 0, sizeof(*G)); } /* }}} */ /* {{{ void php_output_startup(void) Set up module globals and initalize the conflict and reverse conflict hash tables */ PHPAPI void php_output_startup(void) { ZEND_INIT_MODULE_GLOBALS(output, php_output_init_globals, NULL); zend_hash_init(&php_output_handler_aliases, 0, NULL, NULL, 1); zend_hash_init(&php_output_handler_conflicts, 0, NULL, NULL, 1); zend_hash_init(&php_output_handler_reverse_conflicts, 0, NULL, (void (*)(void *)) zend_hash_destroy, 1); } /* }}} */ /* {{{ void php_output_shutdown(void) Destroy module globals and the conflict and reverse conflict hash tables */ PHPAPI void php_output_shutdown(void) { zend_hash_destroy(&php_output_handler_aliases); zend_hash_destroy(&php_output_handler_conflicts); zend_hash_destroy(&php_output_handler_reverse_conflicts); } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_activate(TSRMLS_D) Reset output globals and setup the output handler stack */ PHPAPI int _php_output_activate(TSRMLS_D) { #ifdef ZTS memset((*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(output_globals_id)], 0, sizeof(zend_output_globals)); #else memset(&output_globals, 0, sizeof(zend_output_globals)); #endif if (SUCCESS != zend_stack_init(&OG(handlers))) { return FAILURE; } return SUCCESS; } /* }}} */ /* {{{ void php_output_deactivate(TSRMLS_D) Destroy the output handler stack */ PHPAPI void _php_output_deactivate(TSRMLS_D) { php_output_handler **handler = NULL; OG(active) = NULL; OG(running) = NULL; /* release all output handlers */ while (SUCCESS == zend_stack_top(&OG(handlers), (void *) &handler)) { php_output_handler_free(handler); zend_stack_del_top(&OG(handlers)); } zend_stack_destroy(&OG(handlers)); } /* }}} */ /* {{{ void _php_output_register_constants() */ PHPAPI void _php_output_register_constants(TSRMLS_D) { REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_WRITE", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FLUSH", PHP_OUTPUT_HANDLER_FLUSH, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CLEAN", PHP_OUTPUT_HANDLER_CLEAN, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FINAL", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_END", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CLEANABLE", PHP_OUTPUT_HANDLER_CLEANABLE, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_REMOVABLE", PHP_OUTPUT_HANDLER_REMOVABLE, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_STDFLAGS", PHP_OUTPUT_HANDLER_STDFLAGS, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_STARTED", PHP_OUTPUT_HANDLER_STARTED, CONST_CS | CONST_PERSISTENT); REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_DISABLED", PHP_OUTPUT_HANDLER_DISABLED, CONST_CS | CONST_PERSISTENT); } /* }}} */ /* {{{ void php_output_set_status(int status) Used by SAPIs to disable output */ PHPAPI void _php_output_set_status(int status TSRMLS_DC) { OG(flags) = status & 0xf; } /* }}} */ /* {{{ int php_output_get_status() Get output control status */ PHPAPI int _php_output_get_status(TSRMLS_D) { return OG(flags) | (OG(active) ? PHP_OUTPUT_ACTIVE : 0) | (OG(running)? PHP_OUTPUT_LOCKED : 0); } /* }}} */ /* {{{ int php_output_write_unbuffered(const char *str, size_t len) Unbuffered write */ PHPAPI int _php_output_write_unbuffered(const char *str, size_t len TSRMLS_DC) { if (OG(flags) & PHP_OUTPUT_DISABLED) { return 0; } return sapi_module.ub_write(str, len TSRMLS_CC); } /* }}} */ /* {{{ int php_output_write(const char *str, size_t len) Buffered write */ PHPAPI int _php_output_write(const char *str, size_t len TSRMLS_DC) { if (OG(flags) & PHP_OUTPUT_DISABLED) { return 0; } php_output_op(PHP_OUTPUT_HANDLER_WRITE, str, len TSRMLS_CC); return (int) len; } /* }}} */ /* {{{ void php_output_flush() Flush the most recent output handlers buffer */ PHPAPI void _php_output_flush(TSRMLS_D) { php_output_context context; if (OG(active)) { php_output_context_init(&context, PHP_OUTPUT_HANDLER_FLUSH TSRMLS_CC); php_output_handler_op(OG(active), &context); if (context.out.data && context.out.used) { zend_stack_del_top(&OG(handlers)); php_output_write(context.out.data, context.out.used); zend_stack_push(&OG(handlers), &OG(active), sizeof(php_output_handler *)); } php_output_context_dtor(&context); } } /* }}} */ /* {{{ void php_output_flush_all() Flush all output buffers subsequently */ PHPAPI void _php_output_flush_all(TSRMLS_D) { if (OG(active)) { php_output_op(PHP_OUTPUT_HANDLER_FLUSH, NULL, 0 TSRMLS_CC); } } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_clean() Cleans the most recent output handlers buffer if the handler is cleanable */ PHPAPI int _php_output_clean(TSRMLS_D) { php_output_context context; if (OG(active) && (OG(active)->flags & PHP_OUTPUT_HANDLER_CLEANABLE)) { OG(active)->buffer.used = 0; php_output_context_init(&context, PHP_OUTPUT_HANDLER_CLEAN TSRMLS_CC); php_output_handler_op(OG(active), &context); php_output_context_dtor(&context); return SUCCESS; } return FAILURE; } /* }}} */ /* {{{ void php_output_clean_all() Cleans all output handler buffers, without regard whether the handler is cleanable */ PHPAPI void _php_output_clean_all(TSRMLS_D) { php_output_context context; if (OG(active)) { php_output_context_init(&context, PHP_OUTPUT_HANDLER_CLEAN TSRMLS_CC); zend_stack_apply_with_argument(&OG(handlers), ZEND_STACK_APPLY_TOPDOWN, php_output_stack_apply_clean, &context); } } /* {{{ SUCCESS|FAILURE php_output_end() Finalizes the most recent output handler at pops it off the stack if the handler is removable */ PHPAPI int _php_output_end(TSRMLS_D) { if (php_output_stack_pop(0, 0 TSRMLS_CC)) { return SUCCESS; } return FAILURE; } /* }}} */ /* {{{ void php_output_end_all() Finalizes all output handlers and ends output buffering without regard whether a handler is removable */ PHPAPI void _php_output_end_all(TSRMLS_D) { while (OG(active) && php_output_stack_pop(0, 1 TSRMLS_CC)); } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_discard() Discards the most recent output handlers buffer and pops it off the stack if the handler is removable */ PHPAPI int _php_output_discard(TSRMLS_D) { if (php_output_stack_pop(1, 0 TSRMLS_CC)) { return SUCCESS; } return FAILURE; } /* }}} */ /* {{{ void php_output_discard_all() Discard all output handlers and buffers without regard whether a handler is removable */ PHPAPI void _php_output_discard_all(TSRMLS_D) { while (OG(active)) { php_output_stack_pop(1, 1 TSRMLS_CC); } } /* }}} */ /* {{{ int php_output_get_level() Get output buffering level, ie. how many output handlers the stack contains */ PHPAPI int _php_output_get_level(TSRMLS_D) { return OG(active) ? zend_stack_count(&OG(handlers)) : 0; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_get_contents(zval *z) Get the contents of the active output handlers buffer */ PHPAPI int _php_output_get_contents(zval *p TSRMLS_DC) { if (OG(active)) { ZVAL_STRINGL(p, OG(active)->buffer.data, OG(active)->buffer.used, 1); return SUCCESS; } else { ZVAL_NULL(p); return FAILURE; } } /* {{{ SUCCESS|FAILURE php_output_get_length(zval *z) Get the length of the active output handlers buffer */ PHPAPI int _php_output_get_length(zval *p TSRMLS_DC) { if (OG(active)) { ZVAL_LONG(p, OG(active)->buffer.used); return SUCCESS; } else { ZVAL_NULL(p); return FAILURE; } } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_start_default() Start a "default output handler" */ PHPAPI int _php_output_start_default(TSRMLS_D) { php_output_handler *handler; handler = php_output_handler_create_internal(PHP_OUTPUT_HANDLER_DEFAULT_NAME, php_output_handler_default_func, 0, PHP_OUTPUT_HANDLER_STDFLAGS); if (SUCCESS == php_output_handler_start(handler)) { return SUCCESS; } php_output_handler_free(&handler); return FAILURE; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_start_devnull() Start a "null output handler" */ PHPAPI int _php_output_start_devnull(TSRMLS_D) { php_output_handler *handler; handler = php_output_handler_create_internal(PHP_OUTPUT_HANDLER_DEVNULL_NAME, php_output_handler_devnull_func, PHP_OUTPUT_HANDLER_DEFAULT_SIZE, 0); if (SUCCESS == php_output_handler_start(handler)) { return SUCCESS; } php_output_handler_free(&handler); return FAILURE; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_start_user(zval *handler, size_t chunk_size, int flags) Start a user level output handler */ PHPAPI int _php_output_start_user(zval *output_handler, size_t chunk_size, int flags TSRMLS_DC) { php_output_handler *handler; handler = php_output_handler_create_user(output_handler, chunk_size, flags); if (SUCCESS == php_output_handler_start(handler)) { return SUCCESS; } php_output_handler_free(&handler); return FAILURE; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_start_named(const char *name, size_t chunk_size, int flags) Start a user level output handler by name */ PHPAPI int _php_output_start_named(const char *name, size_t chunk_size, int flags TSRMLS_DC) { php_output_handler *handler; zval *output_handler = NULL; if (!strcmp(name, PHP_OUTPUT_HANDLER_DEFAULT_NAME)) { handler = php_output_handler_create_internal(PHP_OUTPUT_HANDLER_DEFAULT_NAME, php_output_handler_default_func, 0, PHP_OUTPUT_HANDLER_STDFLAGS); } else if (!strcmp(name, PHP_OUTPUT_HANDLER_DEVNULL_NAME)) { handler = php_output_handler_create_internal(PHP_OUTPUT_HANDLER_DEVNULL_NAME, php_output_handler_devnull_func, PHP_OUTPUT_HANDLER_DEFAULT_SIZE, 0); } else { output_handler = ecalloc(1, sizeof(zval)); ZVAL_STRING(output_handler, (char *) name, 1); handler = php_output_handler_create_user(output_handler, chunk_size, flags); } if (SUCCESS == php_output_handler_start(handler)) { return SUCCESS; } php_output_handler_free(&handler); if (output_handler) { zval_ptr_dtor(&output_handler); } return FAILURE; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_start_internal(const char *name, php_output_handler_func_t handler, size_t chunk_size, int flags) Start an internal output handler that does not have to maintain a non-global state */ PHPAPI int _php_output_start_internal(const char *name, php_output_handler_func_t output_handler, size_t chunk_size, int flags TSRMLS_DC) { php_output_handler *handler; handler = php_output_handler_create_internal(name, php_output_handler_compat_func, chunk_size, flags); php_output_handler_set_context(handler, output_handler, NULL); if (SUCCESS == php_output_handler_start(handler)) { return SUCCESS; } php_output_handler_free(&handler); return FAILURE; } /* }}} */ /* {{{ php_output_handler *php_output_handler_create_user(zval *handler, size_t chunk_size, int flags) Create a user level output handler */ PHPAPI php_output_handler *_php_output_handler_create_user(zval *output_handler, size_t chunk_size, int flags TSRMLS_DC) { char *handler_name = NULL; php_output_handler *handler = NULL; php_output_handler_context_func_t *internal = NULL; if ((!output_handler) || (Z_TYPE_P(output_handler) == IS_NULL) || ((Z_TYPE_P(output_handler) == IS_STRING) && (!Z_STRLEN_P(output_handler)))) { handler = php_output_handler_create_internal(PHP_OUTPUT_HANDLER_DEFAULT_NAME, php_output_handler_default_func, chunk_size, flags); } else if ((Z_TYPE_P(output_handler) == IS_STRING) && (internal = php_output_handler_alias_ex(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler)+1))) { handler = php_output_handler_create_internal(Z_STRVAL_P(output_handler), *internal, chunk_size, flags); } else if (zend_is_callable(output_handler, 0, &handler_name)) { handler = php_output_handler_init(handler_name, chunk_size, flags); ZVAL_ADDREF(output_handler); handler->user = output_handler; handler->type = PHP_OUTPUT_HANDLER_USER; } STR_FREE(handler_name); return handler; } /* }}} */ /* {{{ php_output_handler *php_output_handler_create_internal(const char *name, php_output_handler_context_func_t handler, size_t chunk_size, int flags) Create an internal output handler that can maintain a non-global state */ PHPAPI php_output_handler *_php_output_handler_create_internal(const char *name, php_output_handler_context_func_t output_handler, size_t chunk_size, int flags TSRMLS_DC) { php_output_handler *handler; handler = php_output_handler_init(name, chunk_size, flags); handler->internal = output_handler; handler->type = PHP_OUTPUT_HANDLER_INTERNAL; return handler; } /* {{{ void php_output_handler_set_context(php_output_handler *handler, void *opaq, void (*dtor)(void* TSRMLS_DC)) Set the context/state of an output handler. Calls the dtor of the previous context if there is one */ PHPAPI void _php_output_handler_set_context(php_output_handler *handler, void *opaq, void (*dtor)(void* TSRMLS_DC) TSRMLS_DC) { if (handler->dtor && handler->opaq) { handler->dtor(handler->opaq TSRMLS_CC); } handler->dtor = dtor; handler->opaq = opaq; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_start(php_output_handler *handler) Starts the set up output handler and pushes it on top of the stack. Checks for any conflicts regarding the output handler to start */ PHPAPI int _php_output_handler_start(php_output_handler *handler TSRMLS_DC) { HashTable *rconflicts; php_output_handler_conflict_check_t *conflict; if (php_output_lock_error(PHP_OUTPUT_HANDLER_START TSRMLS_CC) || !handler) { return FAILURE; } if (SUCCESS == zend_hash_find(&php_output_handler_conflicts, handler->name, handler->name_len + 1, (void *) &conflict)) { if (SUCCESS != (*conflict)(handler->name TSRMLS_CC)) { return FAILURE; } } if (SUCCESS == zend_hash_find(&php_output_handler_reverse_conflicts, handler->name, handler->name_len + 1, (void *) &rconflicts)) { for ( zend_hash_internal_pointer_reset(rconflicts); zend_hash_get_current_data(rconflicts, (void *) &conflict) == SUCCESS; zend_hash_move_forward(rconflicts)) { if (SUCCESS != (*conflict)(handler->name TSRMLS_CC)) { return FAILURE; } } } /* zend_stack_push never returns SUCCESS but FAILURE or stack level */ if (FAILURE == (handler->level = zend_stack_push(&OG(handlers), &handler, sizeof(php_output_handler *)))) { return FAILURE; } OG(active) = handler; return SUCCESS; } /* }}} */ /* {{{ int php_output_handler_started(const char *name) Check whether a certain output handler is in use */ PHPAPI int _php_output_handler_started(const char *name TSRMLS_DC) { php_output_handler **handlers; int i, count = php_output_get_level(); if (count) { handlers = *(php_output_handler ***) zend_stack_base(&OG(handlers)); for (i = 0; i < count; ++i) { if (!strcmp(handlers[i]->name, name)) { return 1; } } } return 0; } /* }}} */ /* {{{ int php_output_handler_conflict(const char *handler_new, const char *handler_old) Check whether a certain handler is in use and issue a warning that the new handler would conflict with the already used one */ PHPAPI int _php_output_handler_conflict(const char *handler_new, const char *handler_set TSRMLS_DC) { if (php_output_handler_started(handler_set)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "output handler '%s' conflicts with '%s'", handler_new, handler_set); return 1; } return 0; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_conflict_register(const char name[], php_output_handler_conflict_check_t check_func) Register a conflict checking function on MINIT */ PHPAPI int _php_output_handler_conflict_register_ex(const char *handler_name, size_t handler_name_len, php_output_handler_conflict_check_t check_func TSRMLS_DC) { if (!EG(current_module)) { zend_error(E_ERROR, "Cannot register an output handler conflict outside of MINIT"); return FAILURE; } return zend_hash_update(&php_output_handler_conflicts, (char *) handler_name, handler_name_len, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL); } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_reverse_conflict_register(const char name[], php_output_handler_conflict_check_t check_func) Register a reverse conflict checking function on MINIT */ PHPAPI int _php_output_handler_reverse_conflict_register_ex(const char *handler_name, size_t handler_name_len, php_output_handler_conflict_check_t check_func TSRMLS_DC) { HashTable rev, *rev_ptr = NULL; if (!EG(current_module)) { zend_error(E_ERROR, "Cannot register a reverse output handler conflict outside of MINIT"); return FAILURE; } if (SUCCESS == zend_hash_find(&php_output_handler_reverse_conflicts, (char *) handler_name, handler_name_len, (void *) &rev_ptr)) { return zend_hash_next_index_insert(rev_ptr, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL); } else { zend_hash_init(&rev, 1, NULL, NULL, 1); if (SUCCESS != zend_hash_next_index_insert(&rev, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL)) { zend_hash_destroy(&rev); return FAILURE; } if (SUCCESS != zend_hash_update(&php_output_handler_reverse_conflicts, (char *) handler_name, handler_name_len, &rev, sizeof(HashTable), NULL)) { zend_hash_destroy(&rev); return FAILURE; } return SUCCESS; } } /* }}} */ /* {{{ php_output_handler_context_func_t php_output_handler_alias(const char[] name) Get an internal output handler for a user handler if it exists */ PHPAPI php_output_handler_context_func_t *_php_output_handler_alias_ex(const char *handler_name, size_t handler_name_len TSRMLS_DC) { php_output_handler_context_func_t *func = NULL; zend_hash_find(&php_output_handler_aliases, (char *) handler_name, handler_name_len, (void *) &func); return func; } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_alias_register(const char[] name, php_output_handler_context_func_t func) Registers an internal output handler as alias for a user handler */ PHPAPI int _php_output_handler_alias_register_ex(const char *handler_name, size_t handler_name_len, php_output_handler_context_func_t func TSRMLS_DC) { if (!EG(current_module)) { zend_error(E_ERROR, "Cannot register an output handler alias outside of MINIT"); return FAILURE; } return zend_hash_update(&php_output_handler_aliases, (char *) handler_name, handler_name_len, &func, sizeof(php_output_handler_context_func_t *), NULL); } /* }}} */ /* {{{ SUCCESS|FAILURE php_output_handler_hook(int type, void *arg) Output handler hook for output handler functions to check/modify the current handlers abilities */ PHPAPI int _php_output_handler_hook(int type, void *arg TSRMLS_DC) { if (OG(running)) { switch (type) { case PHP_OUTPUT_HANDLER_HOOK_GET_OPAQ: *(void ***) arg = &OG(running)->opaq; return SUCCESS; case PHP_OUTPUT_HANDLER_HOOK_GET_FLAGS: *(int *) arg = OG(running)->flags; return SUCCESS; case PHP_OUTPUT_HANDLER_HOOK_IMMUTABLE: OG(running)->flags &= ~PHP_OUTPUT_HANDLER_STDFLAGS; return SUCCESS; case PHP_OUTPUT_HANDLER_HOOK_DISABLE: OG(running)->flags |= PHP_OUTPUT_HANDLER_DISABLED; return SUCCESS; } } return FAILURE; } /* }}} */ /* {{{ void php_output_handler_dtor(php_output_handler *handler) Destroy an output handler */ PHPAPI void _php_output_handler_dtor(php_output_handler *handler TSRMLS_DC) { STR_FREE(handler->name); STR_FREE(handler->buffer.data); if (handler->type == PHP_OUTPUT_HANDLER_USER) { zval_ptr_dtor(&handler->user); } if (handler->dtor && handler->opaq) { handler->dtor(handler->opaq TSRMLS_CC); } memset(handler, 0, sizeof(*handler)); } /* }}} */ /* {{{ void php_output_handler_free(php_output_handler **handler) Destroy and free an output handler */ PHPAPI void _php_output_handler_free(php_output_handler **h TSRMLS_DC) { if (*h) { php_output_handler_dtor(*h); efree(*h); *h = NULL; } } /* }}} */ /* void php_output_set_implicit_flush(int enabled) Enable or disable implicit flush */ PHPAPI void _php_output_set_implicit_flush(int flush TSRMLS_DC) { if (flush) { OG(flags) |= PHP_OUTPUT_IMPLICITFLUSH; } else { OG(flags) &= ~PHP_OUTPUT_IMPLICITFLUSH; } } /* }}} */ /* {{{ char *php_output_get_start_filename() Get the file name where output has started */ PHPAPI char *_php_output_get_start_filename(TSRMLS_D) { return OG(output_start_filename); } /* }}} */ /* {{{ int php_output_get_start_lineno() Get the line number where output has started */ PHPAPI int _php_output_get_start_lineno(TSRMLS_D) { return OG(output_start_lineno); } /* }}} */ /* {{{ static int php_output_lock_error(int op TSRMLS_DC) Checks whether an unallowed operation is attempted from within the output handler and issues a fatal error */ static inline int php_output_lock_error(int op TSRMLS_DC) { /* if there's no ob active, ob has been stopped */ if (op && OG(active) && OG(running)) { /* fatal error */ php_output_deactivate(); php_error_docref("ref.outcontrol" TSRMLS_CC, E_ERROR, "Cannot use output buffering in output buffering display handlers"); return 1; } return 0; } /* }}} */ /* {{{ static php_output_context *php_output_context_init(php_output_context *context, int op TSRMLS_DC) Initialize a new output context */ static inline php_output_context *php_output_context_init(php_output_context *context, int op TSRMLS_DC) { if (!context) { context = emalloc(sizeof(php_output_context)); } memset(context, 0, sizeof(php_output_context)); TSRMLS_SET_CTX(context->tsrm_ls); context->op = op; return context; } /* }}} */ /* {{{ static void php_output_context_reset(php_output_context *context) Reset an output context */ static inline void php_output_context_reset(php_output_context *context) { int op = context->op; php_output_context_dtor(context); memset(context, 0, sizeof(php_output_context)); context->op = op; } /* }}} */ /* {{{ static void php_output_context_swap(php_output_context *context) Swap output contexts buffers */ static inline void php_output_context_swap(php_output_context *context) { if (context->in.free && context->in.data) { efree(context->in.data); } context->in.data = context->out.data; context->in.used = context->out.used; context->in.free = context->out.free; context->in.size = context->out.size; context->out.data = NULL; context->out.used = 0; context->out.size = 0; } /* }}} */ /* {{{ static void php_output_context_pass(php_output_context *context) Pass input to output buffer */ static inline void php_output_context_pass(php_output_context *context) { context->out.data = context->in.data; context->out.used = context->in.used; context->out.size = context->in.size; context->out.free = context->in.free; context->in.data = NULL; context->in.used = 0; context->in.size = 0; } /* }}} */ /* {{{ static void php_output_context_dtor(php_output_context *context) Destroy the contents of an output context */ static inline void php_output_context_dtor(php_output_context *context) { if (context->in.free && context->in.data) { efree(context->in.data); } if (context->out.free && context->out.data) { efree(context->out.data); } } /* }}} */ /* {{{ static php_output_handler *php_output_handler_init(const char *name, size_t chunk_size, int flags) Allocates and initializes a php_output_handler structure */ static inline php_output_handler *php_output_handler_init(const char *name, size_t chunk_size, int flags) { php_output_handler *handler; handler = ecalloc(1, sizeof(php_output_handler)); handler->name = estrndup(name, handler->name_len = strlen(name)); handler->size = chunk_size; handler->flags = flags; handler->buffer.size = PHP_OUTPUT_HANDLER_INITBUF_SIZE(chunk_size); handler->buffer.data = emalloc(handler->buffer.size); return handler; } /* }}} */ /* {{{ static int php_output_handler_appen(php_output_handler *handler, const php_output_buffer *buf TSRMLS_DC) Appends input to the output handlers buffer and indicates whether the buffer does not have to be processed by the output handler */ static inline int php_output_handler_append(php_output_handler *handler, const php_output_buffer *buf TSRMLS_DC) { /* store it away */ if ((handler->buffer.size - handler->buffer.used) <= buf->used) { size_t grow_int = PHP_OUTPUT_HANDLER_INITBUF_SIZE(handler->size); size_t grow_buf = PHP_OUTPUT_HANDLER_INITBUF_SIZE(buf->used + 1 - (handler->buffer.size - handler->buffer.used)); size_t grow_max = MAX(grow_int, grow_buf); handler->buffer.data = erealloc(handler->buffer.data, handler->buffer.size += grow_max); } memcpy(handler->buffer.data + handler->buffer.used, buf->data, buf->used); handler->buffer.used += buf->used; handler->buffer.data[handler->buffer.used] = '\0'; /* chunked buffering */ if (handler->size && (handler->buffer.used >= handler->size)) { /* store away errors and/or any intermediate output */ return OG(running) ? 1 : 0; } return 1; } /* }}} */ /* {{{ static PHP_OUTPUT_HANDLER_(SUCCESS|FAILURE|NO_DATA) php_output_handler_op(php_output_handler *handler, php_output_context *context) Output handler operation dispatcher, applying context op to the php_output_handler handler */ static inline int php_output_handler_op(php_output_handler *handler, php_output_context *context) { int status, op; TSRMLS_FETCH_FROM_CTX(context->tsrm_ls); #if PHP_OUTPUT_DEBUG fprintf(stderr, ">>> op(%d, " "handler=%p, " "name=%s, " "flags=%d, " "buffer.data=%s, " "buffer.used=%lu, " "buffer.size=%lu, " "in.data=%s, " "in.used=%lu)\n", context->op, handler, handler->name, handler->flags, handler->buffer.data, handler->buffer.used, handler->buffer.size, context->in.data, context->in.used ); #endif op = context->op; if (php_output_lock_error(op TSRMLS_CC)) { /* fatal error */ return PHP_OUTPUT_HANDLER_FAILURE; } /* storable? */ if (php_output_handler_append(handler, &context->in TSRMLS_CC) && !op) { status = PHP_OUTPUT_HANDLER_NO_DATA; } else { /* need to start? */ if (!(handler->flags & PHP_OUTPUT_HANDLER_STARTED)) { handler->flags |= PHP_OUTPUT_HANDLER_STARTED; op |= PHP_OUTPUT_HANDLER_START; } OG(running) = handler; if (handler->type == PHP_OUTPUT_HANDLER_USER) { zval *retval = NULL, **params[2], *flags, *input; MAKE_STD_ZVAL(input); ZVAL_STRINGL(input, handler->buffer.data, handler->buffer.used, 1); MAKE_STD_ZVAL(flags); ZVAL_LONG(flags, (long) op); params[0] = &input; params[1] = &flags; if ( (SUCCESS == call_user_function_ex(CG(function_table), NULL, handler->user, &retval, 2, params, 1, NULL TSRMLS_CC)) && retval && (Z_TYPE_P(retval) != IS_NULL) && (Z_TYPE_P(retval) != IS_BOOL || Z_BVAL_P(retval))) { /* user handler may have returned TRUE */ status = PHP_OUTPUT_HANDLER_NO_DATA; if (Z_TYPE_P(retval) != IS_BOOL) { convert_to_string_ex(&retval); if (Z_STRLEN_P(retval)) { context->out.data = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval)); context->out.used = Z_STRLEN_P(retval); context->out.free = 1; status = PHP_OUTPUT_HANDLER_SUCCESS; } } } else { /* call failed, pass internal buffer along */ status = PHP_OUTPUT_HANDLER_FAILURE; } if (retval) { zval_ptr_dtor(&retval); } zval_ptr_dtor(&input); zval_ptr_dtor(&flags); } else { context->in.data = handler->buffer.data; context->in.used = handler->buffer.used; context->in.free = 0; if (SUCCESS == handler->internal(&handler->opaq, context)) { if (context->out.used) { status = PHP_OUTPUT_HANDLER_SUCCESS; } else { status = PHP_OUTPUT_HANDLER_NO_DATA; } } else { status = PHP_OUTPUT_HANDLER_FAILURE; } } OG(running) = NULL; } switch (status) { case PHP_OUTPUT_HANDLER_FAILURE: /* disable this handler */ handler->flags |= PHP_OUTPUT_HANDLER_DISABLED; /* returns handlers buffer */ context->out.data = handler->buffer.data; context->out.used = handler->buffer.used; context->out.free = 1; handler->buffer.data = NULL; handler->buffer.used = 0; handler->buffer.size = 0; break; case PHP_OUTPUT_HANDLER_SUCCESS: /* no more buffered data */ handler->buffer.used = 0; break; case PHP_OUTPUT_HANDLER_NO_DATA: /* handler ate all */ php_output_context_reset(context); break; } return status; } /* }}} */ /* {{{ static void php_output_op(int op, const char *str, size_t len TSRMLS_DC) Output op dispatcher, passes input and output handlers output through the output handler stack until it gets written to the SAPI */ static inline void php_output_op(int op, const char *str, size_t len TSRMLS_DC) { php_output_context context; php_output_handler **active; int obh_cnt; if (php_output_lock_error(op TSRMLS_CC)) { return; } php_output_context_init(&context, op TSRMLS_CC); /* * broken up for better performance: * - apply op to the one active handler; note that OG(active) might be popped off the stack on a flush * - or apply op to the handler stack */ if (OG(active) && (obh_cnt = zend_stack_count(&OG(handlers)))) { context.in.data = (char *) str; context.in.used = len; if (obh_cnt > 1) { zend_stack_apply_with_argument(&OG(handlers), ZEND_STACK_APPLY_TOPDOWN, php_output_stack_apply_op, &context); } else if ((SUCCESS == zend_stack_top(&OG(handlers), (void *) &active)) && (!((*active)->flags & PHP_OUTPUT_HANDLER_DISABLED))) { php_output_handler_op(*active, &context); } else { php_output_context_pass(&context); } } else { context.out.data = (char *) str; context.out.used = len; } if (context.out.data) { if (context.out.used) { #if PHP_OUTPUT_DEBUG fprintf(stderr, "::: sapi_write('%s', %lu)\n", context.out.data, context.out.used); #endif if (!SG(headers_sent) && php_header(TSRMLS_C)) { if (zend_is_compiling(TSRMLS_C)) { OG(output_start_filename) = zend_get_compiled_filename(TSRMLS_C); OG(output_start_lineno) = zend_get_compiled_lineno(TSRMLS_C); } else if (zend_is_executing(TSRMLS_C)) { OG(output_start_filename) = zend_get_executed_filename(TSRMLS_C); OG(output_start_lineno) = zend_get_executed_lineno(TSRMLS_C); } #if PHP_OUTPUT_DEBUG fprintf(stderr, "!!! output started at: %s (%d)\n", OG(output_start_filename), OG(output_start_lineno)); #endif } sapi_module.ub_write(context.out.data, context.out.used TSRMLS_CC); if (OG(flags) & PHP_OUTPUT_IMPLICITFLUSH) { sapi_flush(TSRMLS_C); } } } php_output_context_dtor(&context); } /* }}} */ /* {{{ static int php_output_stack_apply_op(void *h, void *c) Operation callback for the stack apply function */ static int php_output_stack_apply_op(void *h, void *c) { int status = PHP_OUTPUT_HANDLER_FAILURE, was_disabled; php_output_handler *handler = *(php_output_handler **) h; php_output_context *context = (php_output_context *) c; if (!(was_disabled = (handler->flags & PHP_OUTPUT_HANDLER_DISABLED))) { status = php_output_handler_op(handler, context); } /* * handler ate all => break * handler returned data or failed resp. is disabled => continue */ switch (status) { case PHP_OUTPUT_HANDLER_NO_DATA: return 1; case PHP_OUTPUT_HANDLER_SUCCESS: /* swap contexts buffers, unless this is the last handler in the stack */ if (handler->level) { php_output_context_swap(context); } return 0; case PHP_OUTPUT_HANDLER_FAILURE: default: if (was_disabled) { /* pass input along, if it's the last handler in the stack */ if (!handler->level) { php_output_context_pass(context); } } else { /* swap buffers, unless this is the last handler */ if (handler->level) { php_output_context_swap(context); } } return 0; } } /* }}} */ /* {{{ static int php_output_stack_apply_clean(void *h, void *c) Clean callback for the stack apply function */ static int php_output_stack_apply_clean(void *h, void *c) { php_output_handler *handler = *(php_output_handler **) h; php_output_context *context = (php_output_context *) c; handler->buffer.used = 0; php_output_handler_op(handler, context); php_output_context_reset(context); return 0; } /* }}} */ /* {{{ static int php_output_stack_apply_list(void *h, void *z) List callback for the stack apply function */ static int php_output_stack_apply_list(void *h, void *z) { php_output_handler *handler = *(php_output_handler **) h; zval *array = (zval *) z; add_next_index_stringl(array, handler->name, handler->name_len, 1); return 0; } /* }}} */ /* {{{ static int php_output_stack_apply_status(void *h, void *z) Status callback for the stack apply function */ static int php_output_stack_apply_status(void *h, void *z) { php_output_handler *handler = *(php_output_handler **) h; zval *array = (zval *) z; add_next_index_zval(array, php_output_handler_status(handler, NULL)); return 0; } /* }}} */ /* {{{ static zval *php_output_handler_status(php_output_handler *handler, zval *entry) Returns an array with the status of the output handler */ static inline zval *php_output_handler_status(php_output_handler *handler, zval *entry) { if (!entry) { MAKE_STD_ZVAL(entry); array_init(entry); } add_assoc_stringl(entry, "name", handler->name, handler->name_len, 1); add_assoc_long(entry, "type", (long) handler->type); add_assoc_long(entry, "flags", (long) handler->flags); add_assoc_long(entry, "level", (long) handler->level); add_assoc_long(entry, "chunk_size", (long) handler->size); add_assoc_long(entry, "buffer_size", (long) handler->buffer.size); add_assoc_long(entry, "buffer_used", (long) handler->buffer.used); return entry; } /* }}} */ /* {{{ static int php_output_stack_pop(int discard, int shutdown TSRMLS_DC) Pops an output handler off the stack, ignores whether the handler is removable if shutdown==1, discards the handlers output if discard==1 */ static inline int php_output_stack_pop(int discard, int shutdown TSRMLS_DC) { php_output_context context; php_output_handler **current, *orphan = OG(active); if (!orphan) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete."); return 0; } else if (!shutdown && !(orphan->flags & PHP_OUTPUT_HANDLER_REMOVABLE)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s.", orphan->name); return 0; } else { php_output_context_init(&context, PHP_OUTPUT_HANDLER_FINAL TSRMLS_CC); /* don't run the output handler if it's disabled */ if (!(orphan->flags & PHP_OUTPUT_HANDLER_DISABLED)) { /* didn't it start yet? */ if (!(orphan->flags & PHP_OUTPUT_HANDLER_STARTED)) { context.op |= PHP_OUTPUT_HANDLER_START; } /* signal that we're cleaning up */ if (discard) { context.op |= PHP_OUTPUT_HANDLER_CLEAN; } php_output_handler_op(orphan, &context); } /* pop it off the stack */ zend_stack_del_top(&OG(handlers)); if (SUCCESS == zend_stack_top(&OG(handlers), (void *) ¤t)) { OG(active) = *current; } else { OG(active) = NULL; } /* pass output along */ if (context.out.data && context.out.used && !discard) { php_output_write(context.out.data, context.out.used); } /* destroy the handler (after write!) */ php_output_handler_free(&orphan); php_output_context_dtor(&context); return 1; } } /* }}} */ /* {{{ static SUCCESS|FAILURE php_output_handler_compat_func(void *ctx, int op, const char *in, size_t in_len, char **out, size_t *out_len TSRMLS_DC) php_output_handler_context_func_t for php_output_handler_func_t output handlers */ static int php_output_handler_compat_func(void **handler_context, php_output_context *output_context) { php_output_handler_func_t func = *(php_output_handler_func_t *) handler_context; TSRMLS_FETCH_FROM_CTX(output_context->tsrm_ls); if (func) { func(output_context->in.data, output_context->in.used, &output_context->out.data, &output_context->out.used, output_context->op TSRMLS_CC); output_context->out.free = 1; return SUCCESS; } return FAILURE; } /* }}} */ /* {{{ static SUCCESS|FAILURE php_output_handler_default_func(void *ctx, int op, const char *in, size_t in_len, char **out, size_t *out_len TSRMLS_DC) Default output handler */ static int php_output_handler_default_func(void **handler_context, php_output_context *output_context) { output_context->out.data = output_context->in.data; output_context->out.used = output_context->in.used; output_context->out.free = output_context->in.free; output_context->in.data = NULL; output_context->in.used = 0; return SUCCESS; } /* }}} */ /* {{{ static SUCCESS|FAILURE php_output_handler_devnull_func(void *ctx, int op, const char *in, size_t in_len, char **out, size_t *out_len TSRMLS_DC) Null output handler */ static int php_output_handler_devnull_func(void **handler_context, php_output_context *output_context) { return SUCCESS; } /* }}} */ /* * USERLAND (nearly 1:1 of old output.c) */ /* {{{ proto bool ob_start([ string|array user_function [, int chunk_size [, int flags]]]) Turn on Output Buffering (specifying an optional output handler). */ PHP_FUNCTION(ob_start) { zval *output_handler = NULL; long chunk_size = 0; long flags = PHP_OUTPUT_HANDLER_CLEANABLE|PHP_OUTPUT_HANDLER_REMOVABLE; if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zlb", &output_handler, &chunk_size, &flags)) { RETURN_FALSE; } if (chunk_size < 0) { chunk_size = 0; } if (SUCCESS != php_output_start_user(output_handler, chunk_size, flags)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to create buffer."); RETURN_FALSE; } RETURN_TRUE; } /* }}} */ /* {{{ proto bool ob_flush(void) Flush (send) contents of the output buffer. The last buffer content is sent to next buffer */ PHP_FUNCTION(ob_flush) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (!OG(active)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to flush buffer. No buffer to flush."); RETURN_FALSE; } php_output_flush(); RETURN_TRUE; } /* }}} */ /* {{{ proto bool ob_clean(void) Clean (delete) the current output buffer */ PHP_FUNCTION(ob_clean) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (!OG(active)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete."); RETURN_FALSE; } if (SUCCESS != php_output_clean()) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s.", OG(active)->name); RETURN_FALSE; } RETURN_TRUE; } /* }}} */ /* {{{ proto bool ob_end_flush(void) Flush (send) the output buffer, and delete current output buffer */ PHP_FUNCTION(ob_end_flush) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (!OG(active)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete and flush buffer. No buffer to delete or flush."); RETURN_FALSE; } if (SUCCESS != php_output_end()) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s.", OG(active)->name); RETURN_FALSE; } RETURN_TRUE; } /* }}} */ /* {{{ proto bool ob_end_clean(void) Clean the output buffer, and delete current output buffer */ PHP_FUNCTION(ob_end_clean) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (!OG(active)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete."); RETURN_FALSE; } if (SUCCESS != php_output_discard()) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s.", OG(active)->name); RETURN_FALSE; } RETURN_TRUE; } /* }}} */ /* {{{ proto bool ob_get_flush(void) Get current buffer contents, flush (send) the output buffer, and delete current output buffer */ PHP_FUNCTION(ob_get_flush) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (SUCCESS != php_output_get_contents(return_value)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete and flush buffer. No buffer to delete or flush."); RETURN_FALSE; } if (SUCCESS != php_output_end()) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s.", OG(active)->name); } } /* }}} */ /* {{{ proto bool ob_get_clean(void) Get current buffer contents and delete current output buffer */ PHP_FUNCTION(ob_get_clean) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (SUCCESS != php_output_get_contents(return_value)) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete."); RETURN_FALSE; } if (SUCCESS != php_output_discard()) { php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s.", OG(active)->name); } } /* }}} */ /* {{{ proto string ob_get_contents(void) Return the contents of the output buffer */ PHP_FUNCTION(ob_get_contents) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (SUCCESS != php_output_get_contents(return_value)) { RETURN_FALSE; } } /* }}} */ /* {{{ proto int ob_get_level(void) Return the nesting level of the output buffer */ PHP_FUNCTION(ob_get_level) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } RETURN_LONG(php_output_get_level()); } /* }}} */ /* {{{ proto int ob_get_length(void) Return the length of the output buffer */ PHP_FUNCTION(ob_get_length) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (SUCCESS != php_output_get_length(return_value)) { RETURN_FALSE; } } /* }}} */ /* {{{ proto false|array ob_list_handlers() * List all output_buffers in an array */ PHP_FUNCTION(ob_list_handlers) { if (ZEND_NUM_ARGS()) { ZEND_WRONG_PARAM_COUNT(); } if (!OG(active)) { RETURN_FALSE; } array_init(return_value); zend_stack_apply_with_argument(&OG(handlers), ZEND_STACK_APPLY_BOTTOMUP, php_output_stack_apply_list, return_value); } /* }}} */ /* {{{ proto false|array ob_get_status([bool full_status]) Return the status of the active or all output buffers */ PHP_FUNCTION(ob_get_status) { zend_bool full_status = 0; if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &full_status)) { RETURN_FALSE; } if (!OG(active)) { RETURN_FALSE; } array_init(return_value); if (full_status) { zend_stack_apply_with_argument(&OG(handlers), ZEND_STACK_APPLY_BOTTOMUP, php_output_stack_apply_status, return_value); } else { php_output_handler_status(OG(active), return_value); } } /* }}} */ /* {{{ proto void ob_implicit_flush([int flag]) Turn implicit flush on/off and is equivalent to calling flush() after every output call */ PHP_FUNCTION(ob_implicit_flush) { long flag = 1; if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flag)) { php_output_set_implicit_flush(flag); } } /* }}} */ /* {{{ proto bool output_reset_rewrite_vars(void) Reset(clear) URL rewriter values */ PHP_FUNCTION(output_reset_rewrite_vars) { if (php_url_scanner_reset_vars(TSRMLS_C) == SUCCESS) { RETURN_TRUE; } else { RETURN_FALSE; } } /* }}} */ /* {{{ proto bool output_add_rewrite_var(string name, string value) Add URL rewriter values */ PHP_FUNCTION(output_add_rewrite_var) { char *name, *value; int name_len, value_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name, &name_len, &value, &value_len) == FAILURE) { RETURN_FALSE; } if (php_url_scanner_add_var(name, name_len, value, value_len, 1 TSRMLS_CC) == SUCCESS) { RETURN_TRUE; } else { RETURN_FALSE; } } /* }}} */ /* * COMPAT */ #ifndef PHP_OUTPUT_NOCOMPAT /* {{{ */ PHPAPI int php_body_write(const char *str, uint len TSRMLS_DC) { return php_output_write(str, len); } PHPAPI int php_header_write(const char *str, uint len TSRMLS_DC) { return php_output_write_unbuffered(str, len); } PHPAPI int php_start_ob_buffer(zval *output_handler, uint chunk_size, zend_bool erase TSRMLS_DC) { return php_output_start_user(output_handler, chunk_size, (erase ? PHP_OUTPUT_HANDLER_STDFLAGS : 0)); } PHPAPI int php_start_ob_buffer_named(const char *output_handler_name, uint chunk_size, zend_bool erase TSRMLS_DC) { return php_output_start_named(output_handler_name, chunk_size, (erase ? PHP_OUTPUT_HANDLER_STDFLAGS : 0)); } PHPAPI void php_end_ob_buffer(zend_bool send_buffer, zend_bool just_flush TSRMLS_DC) { if (OG(active)) { if (send_buffer && just_flush) { php_output_flush(); } else if (send_buffer) { php_output_end(); } else if (just_flush) { php_output_clean(); } else { php_output_discard(); } } } PHPAPI void php_end_ob_buffers(zend_bool send_buffer TSRMLS_DC) { if (OG(active)) { if (send_buffer) { php_output_end_all(); } else { php_output_discard_all(); } } } PHPAPI int php_ob_get_buffer(zval *p TSRMLS_DC) { return php_output_get_contents(p); } PHPAPI int php_ob_get_length(zval *p TSRMLS_DC) { return php_output_get_length(p); } PHPAPI void php_start_implicit_flush(TSRMLS_D) { php_output_set_implicit_flush(1); } PHPAPI void php_end_implicit_flush(TSRMLS_D) { php_output_set_implicit_flush(0); } PHPAPI char *php_get_output_start_filename(TSRMLS_D) { return php_output_get_start_filename(); } PHPAPI int php_get_output_start_lineno(TSRMLS_D) { return php_output_get_start_lineno(); } PHPAPI void php_ob_set_internal_handler(php_output_handler_func_t internal_output_handler, uint buffer_size, char *handler_name, zend_bool erase TSRMLS_DC) { (void) php_output_start_internal(handler_name, internal_output_handler, buffer_size, (erase ? PHP_OUTPUT_HANDLER_STDFLAGS : 0)); } PHPAPI int php_ob_handler_used(char *handler_name TSRMLS_DC) { return php_output_handler_started(handler_name); } PHPAPI int php_ob_init_conflict(char *handler_new, char *handler_set TSRMLS_DC) { return php_output_handler_conflict(handler_new, handler_set); } #endif /* !PHP_OUTPUT_NOCOMPAT }}} */ /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim600: sw=4 ts=4 fdm=marker * vim<600: sw=4 ts=4 */