1/*
2   +----------------------------------------------------------------------+
3   | PHP Version 5                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2013 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 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   | Authors: Zeev Suraski <zeev@zend.com>                                |
16   |          Thies C. Arntzen <thies@thieso.net>                         |
17   |          Marcus Boerger <helly@php.net>                              |
18   +----------------------------------------------------------------------+
19*/
20
21/* $Id$ */
22
23#include "php.h"
24#include "ext/standard/head.h"
25#include "ext/standard/basic_functions.h"
26#include "ext/standard/url_scanner_ex.h"
27#if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB)
28#include "ext/zlib/php_zlib.h"
29#endif
30#include "SAPI.h"
31
32#define OB_DEFAULT_HANDLER_NAME "default output handler"
33
34/* output functions */
35static int php_b_body_write(const char *str, uint str_length TSRMLS_DC);
36
37static int php_ob_init(uint initial_size, uint block_size, zval *output_handler, uint chunk_size, zend_bool erase TSRMLS_DC);
38static void php_ob_append(const char *text, uint text_length TSRMLS_DC);
39#if 0
40static void php_ob_prepend(const char *text, uint text_length);
41#endif
42
43#ifdef ZTS
44int output_globals_id;
45#else
46php_output_globals output_globals;
47#endif
48
49/* {{{ php_default_output_func */
50PHPAPI int php_default_output_func(const char *str, uint str_len TSRMLS_DC)
51{
52    fwrite(str, 1, str_len, stderr);
53/* See http://support.microsoft.com/kb/190351 */
54#ifdef PHP_WIN32
55    fflush(stderr);
56#endif
57    return str_len;
58}
59/* }}} */
60
61/* {{{ php_output_init_globals */
62static void php_output_init_globals(php_output_globals *output_globals_p TSRMLS_DC)
63{
64    OG(php_body_write) = php_default_output_func;
65    OG(php_header_write) = php_default_output_func;
66    OG(implicit_flush) = 0;
67    OG(output_start_filename) = NULL;
68    OG(output_start_lineno) = 0;
69}
70/* }}} */
71
72/* {{{ php_output_startup
73 * Start output layer */
74PHPAPI void php_output_startup(void)
75{
76#ifdef ZTS
77    ts_allocate_id(&output_globals_id, sizeof(php_output_globals), (ts_allocate_ctor) php_output_init_globals, NULL);
78#else
79    php_output_init_globals(&output_globals TSRMLS_CC);
80#endif
81}
82/* }}} */
83
84/* {{{ php_output_activate
85 * Initilize output global for activation */
86PHPAPI void php_output_activate(TSRMLS_D)
87{
88    OG(php_body_write) = php_ub_body_write;
89    OG(php_header_write) = sapi_module.ub_write;
90    OG(ob_nesting_level) = 0;
91    OG(ob_lock) = 0;
92    OG(disable_output) = 0;
93    OG(output_start_filename) = NULL;
94    OG(output_start_lineno) = 0;
95}
96/* }}} */
97
98/* {{{ php_output_register_constants */
99void php_output_register_constants(TSRMLS_D)
100{
101    REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT);
102    REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_CONT, CONST_CS | CONST_PERSISTENT);
103    REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_END", PHP_OUTPUT_HANDLER_END, CONST_CS | CONST_PERSISTENT);
104}
105/* }}} */
106
107/* {{{ php_output_set_status
108 * Toggle output status.  Do NOT use in application code, only in SAPIs where appropriate. */
109PHPAPI void php_output_set_status(zend_bool status TSRMLS_DC)
110{
111    OG(disable_output) = !status;
112}
113/* }}} */
114
115/* {{{ php_body_write
116 * Write body part */
117PHPAPI int php_body_write(const char *str, uint str_length TSRMLS_DC)
118{
119    return OG(php_body_write)(str, str_length TSRMLS_CC);
120}
121/* }}} */
122
123/* {{{ php_header_write
124 * Write HTTP header */
125PHPAPI int php_header_write(const char *str, uint str_length TSRMLS_DC)
126{
127    if (OG(disable_output)) {
128        return 0;
129    } else {
130        return OG(php_header_write)(str, str_length TSRMLS_CC);
131    }
132}
133/* }}} */
134
135/* {{{ php_start_ob_buffer
136 * Start output buffering */
137PHPAPI int php_start_ob_buffer(zval *output_handler, uint chunk_size, zend_bool erase TSRMLS_DC)
138{
139    uint initial_size, block_size;
140
141    if (OG(ob_lock)) {
142        if (SG(headers_sent) && !SG(request_info).headers_only) {
143            OG(php_body_write) = php_ub_body_write_no_header;
144        } else {
145            OG(php_body_write) = php_ub_body_write;
146        }
147        OG(ob_nesting_level) = 0;
148        php_error_docref("ref.outcontrol" TSRMLS_CC, E_ERROR, "Cannot use output buffering in output buffering display handlers");
149        return FAILURE;
150    }
151    if (chunk_size > 0) {
152        if (chunk_size==1) {
153            chunk_size = 4096;
154        }
155        initial_size = (chunk_size*3/2);
156        block_size = chunk_size/2;
157    } else {
158        initial_size = 40*1024;
159        block_size = 10*1024;
160    }
161    return php_ob_init(initial_size, block_size, output_handler, chunk_size, erase TSRMLS_CC);
162}
163/* }}} */
164
165/* {{{ php_start_ob_buffer_named
166 * Start output buffering */
167PHPAPI int php_start_ob_buffer_named(const char *output_handler_name, uint chunk_size, zend_bool erase TSRMLS_DC)
168{
169    zval *output_handler;
170    int result;
171
172    ALLOC_INIT_ZVAL(output_handler);
173    Z_STRLEN_P(output_handler) = strlen(output_handler_name);   /* this can be optimized */
174    Z_STRVAL_P(output_handler) = estrndup(output_handler_name, Z_STRLEN_P(output_handler));
175    Z_TYPE_P(output_handler) = IS_STRING;
176    result = php_start_ob_buffer(output_handler, chunk_size, erase TSRMLS_CC);
177    zval_dtor(output_handler);
178    FREE_ZVAL(output_handler);
179    return result;
180}
181/* }}} */
182
183/* {{{ php_end_ob_buffer
184 * End output buffering (one level) */
185PHPAPI void php_end_ob_buffer(zend_bool send_buffer, zend_bool just_flush TSRMLS_DC)
186{
187    char *final_buffer=NULL;
188    unsigned int final_buffer_length=0;
189    zval *alternate_buffer=NULL;
190    char *to_be_destroyed_buffer, *to_be_destroyed_handler_name;
191    char *to_be_destroyed_handled_output[2] = { 0, 0 };
192    int status;
193    php_ob_buffer *prev_ob_buffer_p=NULL;
194    php_ob_buffer orig_ob_buffer;
195
196    if (OG(ob_nesting_level)==0) {
197        return;
198    }
199    status = 0;
200    if (!OG(active_ob_buffer).status & PHP_OUTPUT_HANDLER_START) {
201        /* our first call */
202        status |= PHP_OUTPUT_HANDLER_START;
203    }
204    if (just_flush) {
205        status |= PHP_OUTPUT_HANDLER_CONT;
206    } else {
207        status |= PHP_OUTPUT_HANDLER_END;
208    }
209
210#if 0
211 {
212     FILE *fp;
213     fp = fopen("/tmp/ob_log", "a");
214     fprintf(fp, "NestLevel: %d  ObStatus: %d  HandlerName: %s\n", OG(ob_nesting_level), status, OG(active_ob_buffer).handler_name);
215     fclose(fp);
216 }
217#endif
218
219    if (OG(active_ob_buffer).internal_output_handler) {
220        final_buffer = OG(active_ob_buffer).internal_output_handler_buffer;
221        final_buffer_length = OG(active_ob_buffer).internal_output_handler_buffer_size;
222        OG(active_ob_buffer).internal_output_handler(OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, &final_buffer, &final_buffer_length, status TSRMLS_CC);
223    } else if (OG(active_ob_buffer).output_handler) {
224        zval **params[2];
225        zval *orig_buffer;
226        zval *z_status;
227
228        if(OG(ob_lock)) {
229            if (SG(headers_sent) && !SG(request_info).headers_only) {
230                OG(php_body_write) = php_ub_body_write_no_header;
231            } else {
232                OG(php_body_write) = php_ub_body_write;
233            }
234            OG(ob_nesting_level) = 0;
235            php_error_docref("ref.outcontrol" TSRMLS_CC, E_ERROR, "Cannot use output buffering in output buffering display handlers");
236            return;
237        }
238
239        ALLOC_INIT_ZVAL(orig_buffer);
240        ZVAL_STRINGL(orig_buffer, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
241
242        ALLOC_INIT_ZVAL(z_status);
243        ZVAL_LONG(z_status, status);
244
245        params[0] = &orig_buffer;
246        params[1] = &z_status;
247        OG(ob_lock) = 1;
248
249        if (call_user_function_ex(CG(function_table), NULL, OG(active_ob_buffer).output_handler, &alternate_buffer, 2, params, 1, NULL TSRMLS_CC)==SUCCESS) {
250            if (alternate_buffer && !(Z_TYPE_P(alternate_buffer)==IS_BOOL && Z_BVAL_P(alternate_buffer)==0)) {
251                convert_to_string_ex(&alternate_buffer);
252                final_buffer = Z_STRVAL_P(alternate_buffer);
253                final_buffer_length = Z_STRLEN_P(alternate_buffer);
254            }
255        }
256        OG(ob_lock) = 0;
257        if (!just_flush) {
258            zval_ptr_dtor(&OG(active_ob_buffer).output_handler);
259        }
260        zval_ptr_dtor(&orig_buffer);
261        zval_ptr_dtor(&z_status);
262    }
263
264    if (!final_buffer) {
265        final_buffer = OG(active_ob_buffer).buffer;
266        final_buffer_length = OG(active_ob_buffer).text_length;
267    }
268
269    if (OG(ob_nesting_level)==1) { /* end buffering */
270        if (SG(headers_sent) && !SG(request_info).headers_only) {
271            OG(php_body_write) = php_ub_body_write_no_header;
272        } else {
273            OG(php_body_write) = php_ub_body_write;
274        }
275    }
276
277    to_be_destroyed_buffer = OG(active_ob_buffer).buffer;
278    to_be_destroyed_handler_name = OG(active_ob_buffer).handler_name;
279    if (OG(active_ob_buffer).internal_output_handler
280        && (final_buffer != OG(active_ob_buffer).internal_output_handler_buffer)
281        && (final_buffer != OG(active_ob_buffer).buffer)) {
282        to_be_destroyed_handled_output[0] = final_buffer;
283    }
284
285    if (!just_flush) {
286        if (OG(active_ob_buffer).internal_output_handler) {
287            to_be_destroyed_handled_output[1] = OG(active_ob_buffer).internal_output_handler_buffer;
288        }
289    }
290    if (OG(ob_nesting_level)>1) { /* restore previous buffer */
291        zend_stack_top(&OG(ob_buffers), (void **) &prev_ob_buffer_p);
292        orig_ob_buffer = OG(active_ob_buffer);
293        OG(active_ob_buffer) = *prev_ob_buffer_p;
294        zend_stack_del_top(&OG(ob_buffers));
295        if (!just_flush && OG(ob_nesting_level)==2) { /* destroy the stack */
296            zend_stack_destroy(&OG(ob_buffers));
297        }
298    }
299    OG(ob_nesting_level)--;
300
301    if (send_buffer) {
302        if (just_flush) { /* if flush is called prior to proper end, ensure presence of NUL */
303            final_buffer[final_buffer_length] = '\0';
304        }
305        OG(php_body_write)(final_buffer, final_buffer_length TSRMLS_CC);
306    }
307
308    if (just_flush) { /* we restored the previous ob, return to the current */
309        if (prev_ob_buffer_p) {
310            zend_stack_push(&OG(ob_buffers), &OG(active_ob_buffer), sizeof(php_ob_buffer));
311            OG(active_ob_buffer) = orig_ob_buffer;
312        }
313        OG(ob_nesting_level)++;
314    }
315
316    if (alternate_buffer) {
317        zval_ptr_dtor(&alternate_buffer);
318    }
319
320    if (status & PHP_OUTPUT_HANDLER_END) {
321        efree(to_be_destroyed_handler_name);
322    }
323    if (!just_flush) {
324        efree(to_be_destroyed_buffer);
325    } else {
326        OG(active_ob_buffer).text_length = 0;
327        OG(active_ob_buffer).status |= PHP_OUTPUT_HANDLER_START;
328        OG(php_body_write) = php_b_body_write;
329    }
330    if (to_be_destroyed_handled_output[0]) {
331        efree(to_be_destroyed_handled_output[0]);
332    }
333    if (to_be_destroyed_handled_output[1]) {
334        efree(to_be_destroyed_handled_output[1]);
335    }
336}
337/* }}} */
338
339/* {{{ php_end_ob_buffers
340 * End output buffering (all buffers) */
341PHPAPI void php_end_ob_buffers(zend_bool send_buffer TSRMLS_DC)
342{
343    while (OG(ob_nesting_level)!=0) {
344        php_end_ob_buffer(send_buffer, 0 TSRMLS_CC);
345    }
346}
347/* }}} */
348
349/* {{{ php_start_implicit_flush
350 */
351PHPAPI void php_start_implicit_flush(TSRMLS_D)
352{
353    OG(implicit_flush) = 1;
354}
355/* }}} */
356
357/* {{{ php_end_implicit_flush
358 */
359PHPAPI void php_end_implicit_flush(TSRMLS_D)
360{
361    OG(implicit_flush) = 0;
362}
363/* }}} */
364
365/* {{{ char *php_get_output_start_filename(TSRMLS_D)
366 *  Return filename start output something */
367PHPAPI char *php_get_output_start_filename(TSRMLS_D)
368{
369    return OG(output_start_filename);
370}
371/* }}} */
372
373/* {{{ char *php_get_output_start_lineno(TSRMLS_D)
374 * Return line number start output something */
375PHPAPI int php_get_output_start_lineno(TSRMLS_D)
376{
377    return OG(output_start_lineno);
378}
379/* }}} */
380
381/* {{{ php_ob_set_internal_handler
382 */
383PHPAPI 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)
384{
385    if (OG(ob_nesting_level) == 0 || OG(active_ob_buffer).internal_output_handler || strcmp(OG(active_ob_buffer).handler_name, OB_DEFAULT_HANDLER_NAME)) {
386        php_start_ob_buffer(NULL, buffer_size, erase TSRMLS_CC);
387    }
388
389    OG(active_ob_buffer).internal_output_handler = internal_output_handler;
390    OG(active_ob_buffer).internal_output_handler_buffer = (char *) emalloc(buffer_size);
391    OG(active_ob_buffer).internal_output_handler_buffer_size = buffer_size;
392    if (OG(active_ob_buffer).handler_name) {
393        efree(OG(active_ob_buffer).handler_name);
394    }
395    OG(active_ob_buffer).handler_name = estrdup(handler_name);
396    OG(active_ob_buffer).erase = erase;
397}
398/* }}} */
399
400/*
401 * Output buffering - implementation
402 */
403
404/* {{{ php_ob_allocate
405 */
406static inline void php_ob_allocate(uint text_length TSRMLS_DC)
407{
408    uint new_len = OG(active_ob_buffer).text_length + text_length;
409
410    if (OG(active_ob_buffer).size < new_len) {
411        uint buf_size = OG(active_ob_buffer).size;
412        while (buf_size <= new_len) {
413            buf_size += OG(active_ob_buffer).block_size;
414        }
415
416        OG(active_ob_buffer).buffer = (char *) erealloc(OG(active_ob_buffer).buffer, buf_size+1);
417        OG(active_ob_buffer).size = buf_size;
418    }
419    OG(active_ob_buffer).text_length = new_len;
420}
421/* }}} */
422
423/* {{{ php_ob_init_conflict
424 * Returns 1 if handler_set is already used and generates error message */
425PHPAPI int php_ob_init_conflict(char *handler_new, char *handler_set TSRMLS_DC)
426{
427    if (php_ob_handler_used(handler_set TSRMLS_CC)) {
428        php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "output handler '%s' conflicts with '%s'", handler_new, handler_set);
429        return 1;
430    }
431    return 0;
432}
433/* }}} */
434
435/* {{{ php_ob_init_named
436 */
437static int php_ob_init_named(uint initial_size, uint block_size, char *handler_name, zval *output_handler, uint chunk_size, zend_bool erase TSRMLS_DC)
438{
439    php_ob_buffer tmp_buf;
440
441    if (output_handler && !zend_is_callable(output_handler, 0, NULL TSRMLS_CC)) {
442        return FAILURE;
443    }
444
445    tmp_buf.block_size = block_size;
446    tmp_buf.size = initial_size;
447    tmp_buf.buffer = (char *) emalloc(initial_size+1);
448    tmp_buf.text_length = 0;
449    tmp_buf.output_handler = output_handler;
450    tmp_buf.chunk_size = chunk_size;
451    tmp_buf.status = 0;
452    tmp_buf.internal_output_handler = NULL;
453    tmp_buf.internal_output_handler_buffer = NULL;
454    tmp_buf.internal_output_handler_buffer_size = 0;
455    tmp_buf.handler_name = estrdup(handler_name&&handler_name[0]?handler_name:OB_DEFAULT_HANDLER_NAME);
456    tmp_buf.erase = erase;
457
458    if (OG(ob_nesting_level)>0) {
459#if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB)
460        if (!strncmp(handler_name, "ob_gzhandler", sizeof("ob_gzhandler")) && php_ob_gzhandler_check(TSRMLS_C)) {
461            return FAILURE;
462        }
463#endif
464        if (OG(ob_nesting_level)==1) { /* initialize stack */
465            zend_stack_init(&OG(ob_buffers));
466        }
467        zend_stack_push(&OG(ob_buffers), &OG(active_ob_buffer), sizeof(php_ob_buffer));
468    }
469    OG(ob_nesting_level)++;
470    OG(active_ob_buffer) = tmp_buf;
471    OG(php_body_write) = php_b_body_write;
472    return SUCCESS;
473}
474/* }}} */
475
476/* {{{ php_ob_handler_from_string
477 * Create zval output handler from string */
478static zval* php_ob_handler_from_string(const char *handler_name, int len TSRMLS_DC)
479{
480    zval *output_handler;
481
482    ALLOC_INIT_ZVAL(output_handler);
483    Z_STRLEN_P(output_handler) = len;
484    Z_STRVAL_P(output_handler) = estrndup(handler_name, len);
485    Z_TYPE_P(output_handler) = IS_STRING;
486    return output_handler;
487}
488/* }}} */
489
490/* {{{ php_ob_init
491 */
492static int php_ob_init(uint initial_size, uint block_size, zval *output_handler, uint chunk_size, zend_bool erase TSRMLS_DC)
493{
494    int result = FAILURE, handler_len, len;
495    char *handler_name, *next_handler_name;
496    HashPosition pos;
497    zval **tmp;
498    zval *handler_zval;
499
500    if (output_handler && output_handler->type == IS_STRING) {
501        handler_name = Z_STRVAL_P(output_handler);
502        handler_len  = Z_STRLEN_P(output_handler);
503
504        result = SUCCESS;
505        if (handler_len && handler_name[0] != '\0') {
506            while ((next_handler_name=strchr(handler_name, ',')) != NULL) {
507                len = next_handler_name-handler_name;
508                next_handler_name = estrndup(handler_name, len);
509                handler_zval = php_ob_handler_from_string(next_handler_name, len TSRMLS_CC);
510                result = php_ob_init_named(initial_size, block_size, next_handler_name, handler_zval, chunk_size, erase TSRMLS_CC);
511                if (result != SUCCESS) {
512                    zval_dtor(handler_zval);
513                    FREE_ZVAL(handler_zval);
514                }
515                handler_name += len+1;
516                handler_len -= len+1;
517                efree(next_handler_name);
518            }
519        }
520        if (result == SUCCESS) {
521            handler_zval = php_ob_handler_from_string(handler_name, handler_len TSRMLS_CC);
522            result = php_ob_init_named(initial_size, block_size, handler_name, handler_zval, chunk_size, erase TSRMLS_CC);
523            if (result != SUCCESS) {
524                zval_dtor(handler_zval);
525                FREE_ZVAL(handler_zval);
526            }
527        }
528    } else if (output_handler && output_handler->type == IS_ARRAY) {
529        /* do we have array(object,method) */
530        if (zend_is_callable(output_handler, 0, &handler_name TSRMLS_CC)) {
531            SEPARATE_ZVAL(&output_handler);
532            Z_ADDREF_P(output_handler);
533            result = php_ob_init_named(initial_size, block_size, handler_name, output_handler, chunk_size, erase TSRMLS_CC);
534            efree(handler_name);
535        } else {
536            efree(handler_name);
537            /* init all array elements recursively */
538            zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(output_handler), &pos);
539            while (zend_hash_get_current_data_ex(Z_ARRVAL_P(output_handler), (void **)&tmp, &pos) == SUCCESS) {
540                result = php_ob_init(initial_size, block_size, *tmp, chunk_size, erase TSRMLS_CC);
541                if (result == FAILURE) {
542                    break;
543                }
544                zend_hash_move_forward_ex(Z_ARRVAL_P(output_handler), &pos);
545            }
546        }
547    } else if (output_handler && output_handler->type == IS_OBJECT) {
548        /* do we have callable object */
549        if (zend_is_callable(output_handler, 0, &handler_name TSRMLS_CC)) {
550            SEPARATE_ZVAL(&output_handler);
551            Z_ADDREF_P(output_handler);
552            result = php_ob_init_named(initial_size, block_size, handler_name, output_handler, chunk_size, erase TSRMLS_CC);
553            efree(handler_name);
554        } else {
555            efree(handler_name);
556            php_error_docref(NULL TSRMLS_CC, E_ERROR, "No method name given: use ob_start(array($object,'method')) to specify instance $object and the name of a method of class %s to use as output handler", Z_OBJCE_P(output_handler)->name);
557            result = FAILURE;
558        }
559    } else {
560        result = php_ob_init_named(initial_size, block_size, OB_DEFAULT_HANDLER_NAME, NULL, chunk_size, erase TSRMLS_CC);
561    }
562    return result;
563}
564/* }}} */
565
566/* {{{ php_ob_list_each
567 */
568static int php_ob_list_each(php_ob_buffer *ob_buffer, zval *ob_handler_array)
569{
570    add_next_index_string(ob_handler_array, ob_buffer->handler_name, 1);
571    return 0;
572}
573/* }}} */
574
575/* {{{ php_ob_used_each
576   Sets handler_name to NULL is found */
577static int php_ob_handler_used_each(php_ob_buffer *ob_buffer, char **handler_name)
578{
579    if (!strcmp(ob_buffer->handler_name, *handler_name)) {
580        *handler_name = NULL;
581        return 1;
582    }
583    return 0;
584}
585/* }}} */
586
587/* {{{ php_ob_used
588   returns 1 if given handler_name is used as output_handler */
589PHPAPI int php_ob_handler_used(char *handler_name TSRMLS_DC)
590{
591    char *tmp = handler_name;
592
593    if (OG(ob_nesting_level)) {
594        if (!strcmp(OG(active_ob_buffer).handler_name, handler_name)) {
595            return 1;
596        }
597        if (OG(ob_nesting_level)>1) {
598            zend_stack_apply_with_argument(&OG(ob_buffers), ZEND_STACK_APPLY_BOTTOMUP, (int (*)(void *element, void *)) php_ob_handler_used_each, &tmp);
599        }
600    }
601    return tmp ? 0 : 1;
602}
603/* }}} */
604
605/* {{{ php_ob_append
606 */
607static inline void php_ob_append(const char *text, uint text_length TSRMLS_DC)
608{
609    char *target;
610    uint original_ob_text_length;
611
612    original_ob_text_length=OG(active_ob_buffer).text_length;
613
614    php_ob_allocate(text_length TSRMLS_CC);
615    target = OG(active_ob_buffer).buffer+original_ob_text_length;
616    memcpy(target, text, text_length);
617    target[text_length]=0;
618
619    /* If implicit_flush is On or chunked buffering, send contents to next buffer and return. */
620    if (OG(active_ob_buffer).chunk_size
621        && OG(active_ob_buffer).text_length >= OG(active_ob_buffer).chunk_size) {
622
623        php_end_ob_buffer(1, 1 TSRMLS_CC);
624        return;
625    }
626}
627/* }}} */
628
629#if 0
630static inline void php_ob_prepend(const char *text, uint text_length)
631{
632    char *p, *start;
633    TSRMLS_FETCH();
634
635    php_ob_allocate(text_length TSRMLS_CC);
636
637    /* php_ob_allocate() may change OG(ob_buffer), so we can't initialize p&start earlier */
638    p = OG(ob_buffer)+OG(ob_text_length);
639    start = OG(ob_buffer);
640
641    while (--p>=start) {
642        p[text_length] = *p;
643    }
644    memcpy(OG(ob_buffer), text, text_length);
645    OG(ob_buffer)[OG(active_ob_buffer).text_length]=0;
646}
647#endif
648
649/* {{{ php_ob_get_buffer
650 * Return the current output buffer */
651PHPAPI int php_ob_get_buffer(zval *p TSRMLS_DC)
652{
653    if (OG(ob_nesting_level)==0) {
654        return FAILURE;
655    }
656    ZVAL_STRINGL(p, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
657    return SUCCESS;
658}
659/* }}} */
660
661/* {{{ php_ob_get_length
662 * Return the size of the current output buffer */
663PHPAPI int php_ob_get_length(zval *p TSRMLS_DC)
664{
665    if (OG(ob_nesting_level) == 0) {
666        return FAILURE;
667    }
668    ZVAL_LONG(p, OG(active_ob_buffer).text_length);
669    return SUCCESS;
670}
671/* }}} */
672
673/*
674 * Wrapper functions - implementation
675 */
676
677/* buffered output function */
678static int php_b_body_write(const char *str, uint str_length TSRMLS_DC)
679{
680    php_ob_append(str, str_length TSRMLS_CC);
681    return str_length;
682}
683
684/* {{{ php_ub_body_write_no_header
685 */
686PHPAPI int php_ub_body_write_no_header(const char *str, uint str_length TSRMLS_DC)
687{
688    int result;
689
690    if (OG(disable_output)) {
691        return 0;
692    }
693
694    result = OG(php_header_write)(str, str_length TSRMLS_CC);
695
696    if (OG(implicit_flush)) {
697        sapi_flush(TSRMLS_C);
698    }
699
700    return result;
701}
702/* }}} */
703
704/* {{{ php_ub_body_write
705 */
706PHPAPI int php_ub_body_write(const char *str, uint str_length TSRMLS_DC)
707{
708    int result = 0;
709
710    if (SG(request_info).headers_only) {
711        if(SG(headers_sent)) {
712            return 0;
713        }
714        php_header(TSRMLS_C);
715        zend_bailout();
716    }
717    if (php_header(TSRMLS_C)) {
718        if (zend_is_compiling(TSRMLS_C)) {
719            OG(output_start_filename) = zend_get_compiled_filename(TSRMLS_C);
720            OG(output_start_lineno) = zend_get_compiled_lineno(TSRMLS_C);
721        } else if (zend_is_executing(TSRMLS_C)) {
722            OG(output_start_filename) = zend_get_executed_filename(TSRMLS_C);
723            OG(output_start_lineno) = zend_get_executed_lineno(TSRMLS_C);
724        }
725
726        OG(php_body_write) = php_ub_body_write_no_header;
727        result = php_ub_body_write_no_header(str, str_length TSRMLS_CC);
728    }
729
730    return result;
731}
732/* }}} */
733
734/* {{{ int php_ob_buffer_status(php_ob_buffer *ob_buffer, zval *result)
735 */
736static int php_ob_buffer_status(php_ob_buffer *ob_buffer, zval *result)
737{
738    zval *elem;
739
740    MAKE_STD_ZVAL(elem);
741    array_init(elem);
742
743    add_assoc_long(elem, "chunk_size", ob_buffer->chunk_size);
744    if (!ob_buffer->chunk_size) {
745        add_assoc_long(elem, "size", ob_buffer->size);
746        add_assoc_long(elem, "block_size", ob_buffer->block_size);
747    }
748    if (ob_buffer->internal_output_handler) {
749        add_assoc_long(elem, "type", PHP_OUTPUT_HANDLER_INTERNAL);
750        add_assoc_long(elem, "buffer_size", ob_buffer->internal_output_handler_buffer_size);
751    } else {
752        add_assoc_long(elem, "type", PHP_OUTPUT_HANDLER_USER);
753    }
754    add_assoc_long(elem, "status", ob_buffer->status);
755    add_assoc_string(elem, "name", ob_buffer->handler_name, 1);
756    add_assoc_bool(elem, "del", ob_buffer->erase);
757    add_next_index_zval(result, elem);
758
759    return SUCCESS;
760}
761/* }}} */
762
763/*
764 * USERLAND (nearly 1:1 of old output.c)
765 */
766
767/* {{{ proto bool ob_start([string|array user_function [, int chunk_size [, bool erase]]])
768   Turn on Output Buffering (specifying an optional output handler). */
769PHP_FUNCTION(ob_start)
770{
771    zval *output_handler = NULL;
772    long chunk_size = 0;
773    zend_bool erase = 1;
774
775    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z/lb", &output_handler, &chunk_size, &erase) == FAILURE) {
776        return;
777    }
778
779    if (chunk_size < 0) {
780        chunk_size = 0;
781    }
782
783    if (php_start_ob_buffer(output_handler, chunk_size, erase TSRMLS_CC) == FAILURE) {
784        RETURN_FALSE;
785    }
786    RETURN_TRUE;
787}
788/* }}} */
789
790/* {{{ proto bool ob_flush(void)
791   Flush (send) contents of the output buffer. The last buffer content is sent to next buffer */
792PHP_FUNCTION(ob_flush)
793{
794    if (zend_parse_parameters_none() == FAILURE) {
795        return;
796    }
797
798    if (!OG(ob_nesting_level)) {
799        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to flush buffer. No buffer to flush");
800        RETURN_FALSE;
801    }
802
803    if (!OG(active_ob_buffer).status && !OG(active_ob_buffer).erase) {
804        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to flush buffer %s", OG(active_ob_buffer).handler_name);
805        RETURN_FALSE;
806    }
807
808    php_end_ob_buffer(1, 1 TSRMLS_CC);
809    RETURN_TRUE;
810}
811/* }}} */
812
813/* {{{ proto bool ob_clean(void)
814   Clean (delete) the current output buffer */
815PHP_FUNCTION(ob_clean)
816{
817    if (zend_parse_parameters_none() == FAILURE) {
818        return;
819    }
820
821    if (!OG(ob_nesting_level)) {
822        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete");
823        RETURN_FALSE;
824    }
825
826    if (!OG(active_ob_buffer).status && !OG(active_ob_buffer).erase) {
827        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s", OG(active_ob_buffer).handler_name);
828        RETURN_FALSE;
829    }
830
831    php_end_ob_buffer(0, 1 TSRMLS_CC);
832    RETURN_TRUE;
833}
834/* }}} */
835
836/* {{{ proto bool ob_end_flush(void)
837   Flush (send) the output buffer, and delete current output buffer */
838PHP_FUNCTION(ob_end_flush)
839{
840    if (zend_parse_parameters_none() == FAILURE) {
841        return;
842    }
843
844    if (!OG(ob_nesting_level)) {
845        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete and flush buffer. No buffer to delete or flush");
846        RETURN_FALSE;
847    }
848
849    if (OG(ob_nesting_level) && !OG(active_ob_buffer).status && !OG(active_ob_buffer).erase) {
850        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s", OG(active_ob_buffer).handler_name);
851        RETURN_FALSE;
852    }
853
854    php_end_ob_buffer(1, 0 TSRMLS_CC);
855    RETURN_TRUE;
856}
857/* }}} */
858
859/* {{{ proto bool ob_end_clean(void)
860   Clean the output buffer, and delete current output buffer */
861PHP_FUNCTION(ob_end_clean)
862{
863    if (zend_parse_parameters_none() == FAILURE) {
864        return;
865    }
866
867    if (!OG(ob_nesting_level)) {
868        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete");
869        RETURN_FALSE;
870    }
871
872    if (OG(ob_nesting_level) && !OG(active_ob_buffer).status && !OG(active_ob_buffer).erase) {
873        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s", OG(active_ob_buffer).handler_name);
874        RETURN_FALSE;
875    }
876
877    php_end_ob_buffer(0, 0 TSRMLS_CC);
878    RETURN_TRUE;
879}
880/* }}} */
881
882/* {{{ proto bool ob_get_flush(void)
883   Get current buffer contents, flush (send) the output buffer, and delete current output buffer */
884PHP_FUNCTION(ob_get_flush)
885{
886    if (zend_parse_parameters_none() == FAILURE) {
887        return;
888    }
889
890    if (php_ob_get_buffer(return_value TSRMLS_CC) == FAILURE) {
891        RETURN_FALSE;
892    }
893
894    if (!OG(ob_nesting_level)) {
895        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete and flush buffer. No buffer to delete or flush");
896        zval_dtor(return_value);
897        RETURN_FALSE;
898    }
899
900    if (OG(ob_nesting_level) && !OG(active_ob_buffer).status && !OG(active_ob_buffer).erase) {
901        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s", OG(active_ob_buffer).handler_name);
902        zval_dtor(return_value);
903        RETURN_FALSE;
904    }
905
906    php_end_ob_buffer(1, 0 TSRMLS_CC);
907}
908/* }}} */
909
910/* {{{ proto bool ob_get_clean(void)
911   Get current buffer contents and delete current output buffer */
912PHP_FUNCTION(ob_get_clean)
913{
914    if (zend_parse_parameters_none() == FAILURE) {
915        return;
916    }
917
918    if (php_ob_get_buffer(return_value TSRMLS_CC) == FAILURE) {
919        RETURN_FALSE;
920    }
921
922    if (!OG(ob_nesting_level)) {
923        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer. No buffer to delete");
924        zval_dtor(return_value);
925        RETURN_FALSE;
926    }
927    if (OG(ob_nesting_level) && !OG(active_ob_buffer).status && !OG(active_ob_buffer).erase) {
928        php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to delete buffer %s", OG(active_ob_buffer).handler_name);
929        zval_dtor(return_value);
930        RETURN_FALSE;
931    }
932
933    php_end_ob_buffer(0, 0 TSRMLS_CC);
934}
935/* }}} */
936
937/* {{{ proto string ob_get_contents(void)
938   Return the contents of the output buffer */
939PHP_FUNCTION(ob_get_contents)
940{
941    if (zend_parse_parameters_none() == FAILURE) {
942        return;
943    }
944
945    if (php_ob_get_buffer(return_value TSRMLS_CC) == FAILURE) {
946        RETURN_FALSE;
947    }
948}
949/* }}} */
950
951/* {{{ proto int ob_get_level(void)
952   Return the nesting level of the output buffer */
953PHP_FUNCTION(ob_get_level)
954{
955    if (zend_parse_parameters_none() == FAILURE) {
956        return;
957    }
958
959    RETURN_LONG(OG(ob_nesting_level));
960}
961/* }}} */
962
963/* {{{ proto int ob_get_length(void)
964   Return the length of the output buffer */
965PHP_FUNCTION(ob_get_length)
966{
967    if (zend_parse_parameters_none() == FAILURE) {
968        return;
969    }
970
971    if (php_ob_get_length(return_value TSRMLS_CC) == FAILURE) {
972        RETURN_FALSE;
973    }
974}
975/* }}} */
976
977/* {{{ proto false|array ob_list_handlers()
978   List all output_buffers in an array */
979PHP_FUNCTION(ob_list_handlers)
980{
981    if (zend_parse_parameters_none() == FAILURE) {
982        return;
983    }
984
985    array_init(return_value);
986
987    if (OG(ob_nesting_level)) {
988        if (OG(ob_nesting_level) > 1) {
989            zend_stack_apply_with_argument(&OG(ob_buffers), ZEND_STACK_APPLY_BOTTOMUP, (int (*)(void *element, void *)) php_ob_list_each, return_value);
990        }
991        php_ob_list_each(&OG(active_ob_buffer), return_value);
992    }
993}
994/* }}} */
995
996/* {{{ proto false|array ob_get_status([bool full_status])
997   Return the status of the active or all output buffers */
998PHP_FUNCTION(ob_get_status)
999{
1000    zend_bool full_status = 0;
1001
1002    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &full_status) == FAILURE) {
1003        return;
1004    }
1005
1006    array_init(return_value);
1007
1008    if (full_status) {
1009        if (OG(ob_nesting_level) > 1) {
1010            zend_stack_apply_with_argument(&OG(ob_buffers), ZEND_STACK_APPLY_BOTTOMUP, (int (*)(void *elem, void *))php_ob_buffer_status, return_value);
1011        }
1012        if (OG(ob_nesting_level) > 0 && php_ob_buffer_status(&OG(active_ob_buffer), return_value) == FAILURE) {
1013            RETURN_FALSE;
1014        }
1015    } else if (OG(ob_nesting_level) > 0) {
1016        add_assoc_long(return_value, "level", OG(ob_nesting_level));
1017        if (OG(active_ob_buffer).internal_output_handler) {
1018            add_assoc_long(return_value, "type", PHP_OUTPUT_HANDLER_INTERNAL);
1019        } else {
1020            add_assoc_long(return_value, "type", PHP_OUTPUT_HANDLER_USER);
1021        }
1022        add_assoc_long(return_value, "status", OG(active_ob_buffer).status);
1023        add_assoc_string(return_value, "name", OG(active_ob_buffer).handler_name, 1);
1024        add_assoc_bool(return_value, "del", OG(active_ob_buffer).erase);
1025    }
1026}
1027/* }}} */
1028
1029/* {{{ proto void ob_implicit_flush([int flag])
1030   Turn implicit flush on/off and is equivalent to calling flush() after every output call */
1031PHP_FUNCTION(ob_implicit_flush)
1032{
1033    long flag = 1;
1034
1035    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flag) == FAILURE) {
1036        return;
1037    }
1038
1039    if (flag) {
1040        php_start_implicit_flush(TSRMLS_C);
1041    } else {
1042        php_end_implicit_flush(TSRMLS_C);
1043    }
1044}
1045/* }}} */
1046
1047/* {{{ proto bool output_reset_rewrite_vars(void)
1048   Reset(clear) URL rewriter values */
1049PHP_FUNCTION(output_reset_rewrite_vars)
1050{
1051    if (php_url_scanner_reset_vars(TSRMLS_C) == SUCCESS) {
1052        RETURN_TRUE;
1053    } else {
1054        RETURN_FALSE;
1055    }
1056}
1057/* }}} */
1058
1059/* {{{ proto bool output_add_rewrite_var(string name, string value)
1060   Add URL rewriter values */
1061PHP_FUNCTION(output_add_rewrite_var)
1062{
1063    char *name, *value;
1064    int name_len, value_len;
1065
1066    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name, &name_len, &value, &value_len) == FAILURE) {
1067        return;
1068    }
1069
1070    if (php_url_scanner_add_var(name, name_len, value, value_len, 1 TSRMLS_CC) == SUCCESS) {
1071        RETURN_TRUE;
1072    } else {
1073        RETURN_FALSE;
1074    }
1075}
1076/* }}} */
1077
1078/*
1079 * Local variables:
1080 * tab-width: 4
1081 * c-basic-offset: 4
1082 * End:
1083 * vim600: sw=4 ts=4 fdm=marker
1084 * vim<600: sw=4 ts=4
1085 */
1086