Annotation of embedaddon/php/main/streams/streams.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 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: Wez Furlong <wez@thebrainroom.com> |
! 16: | Borrowed code from: |
! 17: | Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
! 18: | Jim Winstead <jimw@php.net> |
! 19: +----------------------------------------------------------------------+
! 20: */
! 21:
! 22: /* $Id: streams.c 321634 2012-01-01 13:15:04Z felipe $ */
! 23:
! 24: #define _GNU_SOURCE
! 25: #include "php.h"
! 26: #include "php_globals.h"
! 27: #include "php_network.h"
! 28: #include "php_open_temporary_file.h"
! 29: #include "ext/standard/file.h"
! 30: #include "ext/standard/basic_functions.h" /* for BG(mmap_file) (not strictly required) */
! 31: #include "ext/standard/php_string.h" /* for php_memnstr, used by php_stream_get_record() */
! 32: #include <stddef.h>
! 33: #include <fcntl.h>
! 34: #include "php_streams_int.h"
! 35:
! 36: /* {{{ resource and registration code */
! 37: /* Global wrapper hash, copied to FG(stream_wrappers) on registration of volatile wrapper */
! 38: static HashTable url_stream_wrappers_hash;
! 39: static int le_stream = FAILURE; /* true global */
! 40: static int le_pstream = FAILURE; /* true global */
! 41: static int le_stream_filter = FAILURE; /* true global */
! 42:
! 43: PHPAPI int php_file_le_stream(void)
! 44: {
! 45: return le_stream;
! 46: }
! 47:
! 48: PHPAPI int php_file_le_pstream(void)
! 49: {
! 50: return le_pstream;
! 51: }
! 52:
! 53: PHPAPI int php_file_le_stream_filter(void)
! 54: {
! 55: return le_stream_filter;
! 56: }
! 57:
! 58: PHPAPI HashTable *_php_stream_get_url_stream_wrappers_hash(TSRMLS_D)
! 59: {
! 60: return (FG(stream_wrappers) ? FG(stream_wrappers) : &url_stream_wrappers_hash);
! 61: }
! 62:
! 63: PHPAPI HashTable *php_stream_get_url_stream_wrappers_hash_global(void)
! 64: {
! 65: return &url_stream_wrappers_hash;
! 66: }
! 67:
! 68: static int _php_stream_release_context(zend_rsrc_list_entry *le, void *pContext TSRMLS_DC)
! 69: {
! 70: if (le->ptr == pContext) {
! 71: return --le->refcount == 0;
! 72: }
! 73: return 0;
! 74: }
! 75:
! 76: static int forget_persistent_resource_id_numbers(zend_rsrc_list_entry *rsrc TSRMLS_DC)
! 77: {
! 78: php_stream *stream;
! 79:
! 80: if (Z_TYPE_P(rsrc) != le_pstream) {
! 81: return 0;
! 82: }
! 83:
! 84: stream = (php_stream*)rsrc->ptr;
! 85:
! 86: #if STREAM_DEBUG
! 87: fprintf(stderr, "forget_persistent: %s:%p\n", stream->ops->label, stream);
! 88: #endif
! 89:
! 90: stream->rsrc_id = FAILURE;
! 91:
! 92: if (stream->context) {
! 93: zend_hash_apply_with_argument(&EG(regular_list),
! 94: (apply_func_arg_t) _php_stream_release_context,
! 95: stream->context TSRMLS_CC);
! 96: stream->context = NULL;
! 97: }
! 98:
! 99: return 0;
! 100: }
! 101:
! 102: PHP_RSHUTDOWN_FUNCTION(streams)
! 103: {
! 104: zend_hash_apply(&EG(persistent_list), (apply_func_t)forget_persistent_resource_id_numbers TSRMLS_CC);
! 105: return SUCCESS;
! 106: }
! 107:
! 108: PHPAPI int php_stream_from_persistent_id(const char *persistent_id, php_stream **stream TSRMLS_DC)
! 109: {
! 110: zend_rsrc_list_entry *le;
! 111:
! 112: if (zend_hash_find(&EG(persistent_list), (char*)persistent_id, strlen(persistent_id)+1, (void*) &le) == SUCCESS) {
! 113: if (Z_TYPE_P(le) == le_pstream) {
! 114: if (stream) {
! 115: HashPosition pos;
! 116: zend_rsrc_list_entry *regentry;
! 117: ulong index = -1; /* intentional */
! 118:
! 119: /* see if this persistent resource already has been loaded to the
! 120: * regular list; allowing the same resource in several entries in the
! 121: * regular list causes trouble (see bug #54623) */
! 122: zend_hash_internal_pointer_reset_ex(&EG(regular_list), &pos);
! 123: while (zend_hash_get_current_data_ex(&EG(regular_list),
! 124: (void **)®entry, &pos) == SUCCESS) {
! 125: if (regentry->ptr == le->ptr) {
! 126: zend_hash_get_current_key_ex(&EG(regular_list), NULL, NULL,
! 127: &index, 0, &pos);
! 128: break;
! 129: }
! 130: zend_hash_move_forward_ex(&EG(regular_list), &pos);
! 131: }
! 132:
! 133: *stream = (php_stream*)le->ptr;
! 134: if (index == -1) { /* not found in regular list */
! 135: le->refcount++;
! 136: (*stream)->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, *stream, le_pstream);
! 137: } else {
! 138: regentry->refcount++;
! 139: (*stream)->rsrc_id = index;
! 140: }
! 141: }
! 142: return PHP_STREAM_PERSISTENT_SUCCESS;
! 143: }
! 144: return PHP_STREAM_PERSISTENT_FAILURE;
! 145: }
! 146: return PHP_STREAM_PERSISTENT_NOT_EXIST;
! 147: }
! 148:
! 149: /* }}} */
! 150:
! 151: /* {{{ wrapper error reporting */
! 152: void php_stream_display_wrapper_errors(php_stream_wrapper *wrapper, const char *path, const char *caption TSRMLS_DC)
! 153: {
! 154: char *tmp = estrdup(path);
! 155: char *msg;
! 156: int free_msg = 0;
! 157: php_stream_wrapper orig_wrapper;
! 158:
! 159: if (wrapper) {
! 160: if (wrapper->err_count > 0) {
! 161: int i;
! 162: size_t l;
! 163: int brlen;
! 164: char *br;
! 165:
! 166: if (PG(html_errors)) {
! 167: brlen = 7;
! 168: br = "<br />\n";
! 169: } else {
! 170: brlen = 1;
! 171: br = "\n";
! 172: }
! 173:
! 174: for (i = 0, l = 0; i < wrapper->err_count; i++) {
! 175: l += strlen(wrapper->err_stack[i]);
! 176: if (i < wrapper->err_count - 1) {
! 177: l += brlen;
! 178: }
! 179: }
! 180: msg = emalloc(l + 1);
! 181: msg[0] = '\0';
! 182: for (i = 0; i < wrapper->err_count; i++) {
! 183: strcat(msg, wrapper->err_stack[i]);
! 184: if (i < wrapper->err_count - 1) {
! 185: strcat(msg, br);
! 186: }
! 187: }
! 188:
! 189: free_msg = 1;
! 190: } else {
! 191: if (wrapper == &php_plain_files_wrapper) {
! 192: msg = strerror(errno);
! 193: } else {
! 194: msg = "operation failed";
! 195: }
! 196: }
! 197: } else {
! 198: msg = "no suitable wrapper could be found";
! 199: }
! 200:
! 201: php_strip_url_passwd(tmp);
! 202: if (wrapper) {
! 203: /* see bug #52935 */
! 204: orig_wrapper = *wrapper;
! 205: wrapper->err_stack = NULL;
! 206: wrapper->err_count = 0;
! 207: }
! 208: php_error_docref1(NULL TSRMLS_CC, tmp, E_WARNING, "%s: %s", caption, msg);
! 209: if (wrapper) {
! 210: *wrapper = orig_wrapper;
! 211: }
! 212: efree(tmp);
! 213: if (free_msg) {
! 214: efree(msg);
! 215: }
! 216: }
! 217:
! 218: void php_stream_tidy_wrapper_error_log(php_stream_wrapper *wrapper TSRMLS_DC)
! 219: {
! 220: if (wrapper) {
! 221: /* tidy up the error stack */
! 222: int i;
! 223:
! 224: for (i = 0; i < wrapper->err_count; i++) {
! 225: efree(wrapper->err_stack[i]);
! 226: }
! 227: if (wrapper->err_stack) {
! 228: efree(wrapper->err_stack);
! 229: }
! 230: wrapper->err_stack = NULL;
! 231: wrapper->err_count = 0;
! 232: }
! 233: }
! 234:
! 235: PHPAPI void php_stream_wrapper_log_error(php_stream_wrapper *wrapper, int options TSRMLS_DC, const char *fmt, ...)
! 236: {
! 237: va_list args;
! 238: char *buffer = NULL;
! 239:
! 240: va_start(args, fmt);
! 241: vspprintf(&buffer, 0, fmt, args);
! 242: va_end(args);
! 243:
! 244: if (options & REPORT_ERRORS || wrapper == NULL) {
! 245: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", buffer);
! 246: efree(buffer);
! 247: } else {
! 248: /* append to stack */
! 249: wrapper->err_stack = erealloc(wrapper->err_stack, (wrapper->err_count + 1) * sizeof(char *));
! 250: if (wrapper->err_stack) {
! 251: wrapper->err_stack[wrapper->err_count++] = buffer;
! 252: }
! 253: }
! 254: }
! 255:
! 256:
! 257: /* }}} */
! 258:
! 259: /* allocate a new stream for a particular ops */
! 260: PHPAPI php_stream *_php_stream_alloc(php_stream_ops *ops, void *abstract, const char *persistent_id, const char *mode STREAMS_DC TSRMLS_DC) /* {{{ */
! 261: {
! 262: php_stream *ret;
! 263:
! 264: ret = (php_stream*) pemalloc_rel_orig(sizeof(php_stream), persistent_id ? 1 : 0);
! 265:
! 266: memset(ret, 0, sizeof(php_stream));
! 267:
! 268: ret->readfilters.stream = ret;
! 269: ret->writefilters.stream = ret;
! 270:
! 271: #if STREAM_DEBUG
! 272: fprintf(stderr, "stream_alloc: %s:%p persistent=%s\n", ops->label, ret, persistent_id);
! 273: #endif
! 274:
! 275: ret->ops = ops;
! 276: ret->abstract = abstract;
! 277: ret->is_persistent = persistent_id ? 1 : 0;
! 278: ret->chunk_size = FG(def_chunk_size);
! 279:
! 280: #if ZEND_DEBUG
! 281: ret->open_filename = __zend_orig_filename ? __zend_orig_filename : __zend_filename;
! 282: ret->open_lineno = __zend_orig_lineno ? __zend_orig_lineno : __zend_lineno;
! 283: #endif
! 284:
! 285: if (FG(auto_detect_line_endings)) {
! 286: ret->flags |= PHP_STREAM_FLAG_DETECT_EOL;
! 287: }
! 288:
! 289: if (persistent_id) {
! 290: zend_rsrc_list_entry le;
! 291:
! 292: Z_TYPE(le) = le_pstream;
! 293: le.ptr = ret;
! 294: le.refcount = 0;
! 295:
! 296: if (FAILURE == zend_hash_update(&EG(persistent_list), (char *)persistent_id,
! 297: strlen(persistent_id) + 1,
! 298: (void *)&le, sizeof(le), NULL)) {
! 299:
! 300: pefree(ret, 1);
! 301: return NULL;
! 302: }
! 303: }
! 304:
! 305: ret->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ret, persistent_id ? le_pstream : le_stream);
! 306: strlcpy(ret->mode, mode, sizeof(ret->mode));
! 307:
! 308: return ret;
! 309: }
! 310: /* }}} */
! 311:
! 312: static int _php_stream_free_persistent(zend_rsrc_list_entry *le, void *pStream TSRMLS_DC)
! 313: {
! 314: return le->ptr == pStream;
! 315: }
! 316:
! 317: PHPAPI int _php_stream_free(php_stream *stream, int close_options TSRMLS_DC) /* {{{ */
! 318: {
! 319: int ret = 1;
! 320: int remove_rsrc = 1;
! 321: int preserve_handle = close_options & PHP_STREAM_FREE_PRESERVE_HANDLE ? 1 : 0;
! 322: int release_cast = 1;
! 323: php_stream_context *context = stream->context;
! 324:
! 325: if (stream->flags & PHP_STREAM_FLAG_NO_CLOSE) {
! 326: preserve_handle = 1;
! 327: }
! 328:
! 329: #if STREAM_DEBUG
! 330: fprintf(stderr, "stream_free: %s:%p[%s] in_free=%d opts=%08x\n", stream->ops->label, stream, stream->orig_path, stream->in_free, close_options);
! 331: #endif
! 332:
! 333: /* recursion protection */
! 334: if (stream->in_free) {
! 335: return 1;
! 336: }
! 337:
! 338: stream->in_free++;
! 339:
! 340: /* if we are releasing the stream only (and preserving the underlying handle),
! 341: * we need to do things a little differently.
! 342: * We are only ever called like this when the stream is cast to a FILE*
! 343: * for include (or other similar) purposes.
! 344: * */
! 345: if (preserve_handle) {
! 346: if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
! 347: /* If the stream was fopencookied, we must NOT touch anything
! 348: * here, as the cookied stream relies on it all.
! 349: * Instead, mark the stream as OK to auto-clean */
! 350: php_stream_auto_cleanup(stream);
! 351: stream->in_free--;
! 352: return 0;
! 353: }
! 354: /* otherwise, make sure that we don't close the FILE* from a cast */
! 355: release_cast = 0;
! 356: }
! 357:
! 358: #if STREAM_DEBUG
! 359: fprintf(stderr, "stream_free: %s:%p[%s] preserve_handle=%d release_cast=%d remove_rsrc=%d\n",
! 360: stream->ops->label, stream, stream->orig_path, preserve_handle, release_cast, remove_rsrc);
! 361: #endif
! 362:
! 363: /* make sure everything is saved */
! 364: _php_stream_flush(stream, 1 TSRMLS_CC);
! 365:
! 366: /* If not called from the resource dtor, remove the stream from the resource list. */
! 367: if ((close_options & PHP_STREAM_FREE_RSRC_DTOR) == 0 && remove_rsrc) {
! 368: /* zend_list_delete actually only decreases the refcount; if we're
! 369: * releasing the stream, we want to actually delete the resource from
! 370: * the resource list, otherwise the resource will point to invalid memory.
! 371: * In any case, let's always completely delete it from the resource list,
! 372: * not only when PHP_STREAM_FREE_RELEASE_STREAM is set */
! 373: while (zend_list_delete(stream->rsrc_id) == SUCCESS) {}
! 374: }
! 375:
! 376: /* Remove stream from any context link list */
! 377: if (stream->context && stream->context->links) {
! 378: php_stream_context_del_link(stream->context, stream);
! 379: }
! 380:
! 381: if (close_options & PHP_STREAM_FREE_CALL_DTOR) {
! 382: if (release_cast && stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
! 383: /* calling fclose on an fopencookied stream will ultimately
! 384: call this very same function. If we were called via fclose,
! 385: the cookie_closer unsets the fclose_stdiocast flags, so
! 386: we can be sure that we only reach here when PHP code calls
! 387: php_stream_free.
! 388: Lets let the cookie code clean it all up.
! 389: */
! 390: stream->in_free = 0;
! 391: return fclose(stream->stdiocast);
! 392: }
! 393:
! 394: ret = stream->ops->close(stream, preserve_handle ? 0 : 1 TSRMLS_CC);
! 395: stream->abstract = NULL;
! 396:
! 397: /* tidy up any FILE* that might have been fdopened */
! 398: if (release_cast && stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FDOPEN && stream->stdiocast) {
! 399: fclose(stream->stdiocast);
! 400: stream->stdiocast = NULL;
! 401: stream->fclose_stdiocast = PHP_STREAM_FCLOSE_NONE;
! 402: }
! 403: }
! 404:
! 405: if (close_options & PHP_STREAM_FREE_RELEASE_STREAM) {
! 406: while (stream->readfilters.head) {
! 407: php_stream_filter_remove(stream->readfilters.head, 1 TSRMLS_CC);
! 408: }
! 409: while (stream->writefilters.head) {
! 410: php_stream_filter_remove(stream->writefilters.head, 1 TSRMLS_CC);
! 411: }
! 412:
! 413: if (stream->wrapper && stream->wrapper->wops && stream->wrapper->wops->stream_closer) {
! 414: stream->wrapper->wops->stream_closer(stream->wrapper, stream TSRMLS_CC);
! 415: stream->wrapper = NULL;
! 416: }
! 417:
! 418: if (stream->wrapperdata) {
! 419: zval_ptr_dtor(&stream->wrapperdata);
! 420: stream->wrapperdata = NULL;
! 421: }
! 422:
! 423: if (stream->readbuf) {
! 424: pefree(stream->readbuf, stream->is_persistent);
! 425: stream->readbuf = NULL;
! 426: }
! 427:
! 428: if (stream->is_persistent && (close_options & PHP_STREAM_FREE_PERSISTENT)) {
! 429: /* we don't work with *stream but need its value for comparison */
! 430: zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) _php_stream_free_persistent, stream TSRMLS_CC);
! 431: }
! 432: #if ZEND_DEBUG
! 433: if ((close_options & PHP_STREAM_FREE_RSRC_DTOR) && (stream->__exposed == 0) && (EG(error_reporting) & E_WARNING)) {
! 434: /* it leaked: Lets deliberately NOT pefree it so that the memory manager shows it
! 435: * as leaked; it will log a warning, but lets help it out and display what kind
! 436: * of stream it was. */
! 437: char *leakinfo;
! 438: spprintf(&leakinfo, 0, __FILE__ "(%d) : Stream of type '%s' %p (path:%s) was not closed\n", __LINE__, stream->ops->label, stream, stream->orig_path);
! 439:
! 440: if (stream->orig_path) {
! 441: pefree(stream->orig_path, stream->is_persistent);
! 442: stream->orig_path = NULL;
! 443: }
! 444:
! 445: # if defined(PHP_WIN32)
! 446: OutputDebugString(leakinfo);
! 447: # else
! 448: fprintf(stderr, "%s", leakinfo);
! 449: # endif
! 450: efree(leakinfo);
! 451: } else {
! 452: if (stream->orig_path) {
! 453: pefree(stream->orig_path, stream->is_persistent);
! 454: stream->orig_path = NULL;
! 455: }
! 456:
! 457: pefree(stream, stream->is_persistent);
! 458: }
! 459: #else
! 460: if (stream->orig_path) {
! 461: pefree(stream->orig_path, stream->is_persistent);
! 462: stream->orig_path = NULL;
! 463: }
! 464:
! 465: pefree(stream, stream->is_persistent);
! 466: #endif
! 467: }
! 468:
! 469: if (context) {
! 470: zend_list_delete(context->rsrc_id);
! 471: }
! 472:
! 473: return ret;
! 474: }
! 475: /* }}} */
! 476:
! 477: /* {{{ generic stream operations */
! 478:
! 479: static void php_stream_fill_read_buffer(php_stream *stream, size_t size TSRMLS_DC)
! 480: {
! 481: /* allocate/fill the buffer */
! 482:
! 483: if (stream->readfilters.head) {
! 484: char *chunk_buf;
! 485: int err_flag = 0;
! 486: php_stream_bucket_brigade brig_in = { NULL, NULL }, brig_out = { NULL, NULL };
! 487: php_stream_bucket_brigade *brig_inp = &brig_in, *brig_outp = &brig_out, *brig_swap;
! 488:
! 489: /* Invalidate the existing cache, otherwise reads can fail, see note in
! 490: main/streams/filter.c::_php_stream_filter_append */
! 491: stream->writepos = stream->readpos = 0;
! 492:
! 493: /* allocate a buffer for reading chunks */
! 494: chunk_buf = emalloc(stream->chunk_size);
! 495:
! 496: while (!stream->eof && !err_flag && (stream->writepos - stream->readpos < (off_t)size)) {
! 497: size_t justread = 0;
! 498: int flags;
! 499: php_stream_bucket *bucket;
! 500: php_stream_filter_status_t status = PSFS_ERR_FATAL;
! 501: php_stream_filter *filter;
! 502:
! 503: /* read a chunk into a bucket */
! 504: justread = stream->ops->read(stream, chunk_buf, stream->chunk_size TSRMLS_CC);
! 505: if (justread && justread != (size_t)-1) {
! 506: bucket = php_stream_bucket_new(stream, chunk_buf, justread, 0, 0 TSRMLS_CC);
! 507:
! 508: /* after this call, bucket is owned by the brigade */
! 509: php_stream_bucket_append(brig_inp, bucket TSRMLS_CC);
! 510:
! 511: flags = PSFS_FLAG_NORMAL;
! 512: } else {
! 513: flags = stream->eof ? PSFS_FLAG_FLUSH_CLOSE : PSFS_FLAG_FLUSH_INC;
! 514: }
! 515:
! 516: /* wind the handle... */
! 517: for (filter = stream->readfilters.head; filter; filter = filter->next) {
! 518: status = filter->fops->filter(stream, filter, brig_inp, brig_outp, NULL, flags TSRMLS_CC);
! 519:
! 520: if (status != PSFS_PASS_ON) {
! 521: break;
! 522: }
! 523:
! 524: /* brig_out becomes brig_in.
! 525: * brig_in will always be empty here, as the filter MUST attach any un-consumed buckets
! 526: * to its own brigade */
! 527: brig_swap = brig_inp;
! 528: brig_inp = brig_outp;
! 529: brig_outp = brig_swap;
! 530: memset(brig_outp, 0, sizeof(*brig_outp));
! 531: }
! 532:
! 533: switch (status) {
! 534: case PSFS_PASS_ON:
! 535: /* we get here when the last filter in the chain has data to pass on.
! 536: * in this situation, we are passing the brig_in brigade into the
! 537: * stream read buffer */
! 538: while (brig_inp->head) {
! 539: bucket = brig_inp->head;
! 540: /* grow buffer to hold this bucket
! 541: * TODO: this can fail for persistent streams */
! 542: if (stream->readbuflen - stream->writepos < bucket->buflen) {
! 543: stream->readbuflen += bucket->buflen;
! 544: stream->readbuf = perealloc(stream->readbuf, stream->readbuflen,
! 545: stream->is_persistent);
! 546: }
! 547: memcpy(stream->readbuf + stream->writepos, bucket->buf, bucket->buflen);
! 548: stream->writepos += bucket->buflen;
! 549:
! 550: php_stream_bucket_unlink(bucket TSRMLS_CC);
! 551: php_stream_bucket_delref(bucket TSRMLS_CC);
! 552: }
! 553: break;
! 554:
! 555: case PSFS_FEED_ME:
! 556: /* when a filter needs feeding, there is no brig_out to deal with.
! 557: * we simply continue the loop; if the caller needs more data,
! 558: * we will read again, otherwise out job is done here */
! 559: if (justread == 0) {
! 560: /* there is no data */
! 561: err_flag = 1;
! 562: break;
! 563: }
! 564: continue;
! 565:
! 566: case PSFS_ERR_FATAL:
! 567: /* some fatal error. Theoretically, the stream is borked, so all
! 568: * further reads should fail. */
! 569: err_flag = 1;
! 570: break;
! 571: }
! 572:
! 573: if (justread == 0 || justread == (size_t)-1) {
! 574: break;
! 575: }
! 576: }
! 577:
! 578: efree(chunk_buf);
! 579:
! 580: } else {
! 581: /* is there enough data in the buffer ? */
! 582: if (stream->writepos - stream->readpos < (off_t)size) {
! 583: size_t justread = 0;
! 584:
! 585: /* reduce buffer memory consumption if possible, to avoid a realloc */
! 586: if (stream->readbuf && stream->readbuflen - stream->writepos < stream->chunk_size) {
! 587: memmove(stream->readbuf, stream->readbuf + stream->readpos, stream->readbuflen - stream->readpos);
! 588: stream->writepos -= stream->readpos;
! 589: stream->readpos = 0;
! 590: }
! 591:
! 592: /* grow the buffer if required
! 593: * TODO: this can fail for persistent streams */
! 594: if (stream->readbuflen - stream->writepos < stream->chunk_size) {
! 595: stream->readbuflen += stream->chunk_size;
! 596: stream->readbuf = perealloc(stream->readbuf, stream->readbuflen,
! 597: stream->is_persistent);
! 598: }
! 599:
! 600: justread = stream->ops->read(stream, stream->readbuf + stream->writepos,
! 601: stream->readbuflen - stream->writepos
! 602: TSRMLS_CC);
! 603:
! 604: if (justread != (size_t)-1) {
! 605: stream->writepos += justread;
! 606: }
! 607: }
! 608: }
! 609: }
! 610:
! 611: PHPAPI size_t _php_stream_read(php_stream *stream, char *buf, size_t size TSRMLS_DC)
! 612: {
! 613: size_t toread = 0, didread = 0;
! 614:
! 615: while (size > 0) {
! 616:
! 617: /* take from the read buffer first.
! 618: * It is possible that a buffered stream was switched to non-buffered, so we
! 619: * drain the remainder of the buffer before using the "raw" read mode for
! 620: * the excess */
! 621: if (stream->writepos > stream->readpos) {
! 622:
! 623: toread = stream->writepos - stream->readpos;
! 624: if (toread > size) {
! 625: toread = size;
! 626: }
! 627:
! 628: memcpy(buf, stream->readbuf + stream->readpos, toread);
! 629: stream->readpos += toread;
! 630: size -= toread;
! 631: buf += toread;
! 632: didread += toread;
! 633: }
! 634:
! 635: /* ignore eof here; the underlying state might have changed */
! 636: if (size == 0) {
! 637: break;
! 638: }
! 639:
! 640: if (!stream->readfilters.head && (stream->flags & PHP_STREAM_FLAG_NO_BUFFER || stream->chunk_size == 1)) {
! 641: toread = stream->ops->read(stream, buf, size TSRMLS_CC);
! 642: } else {
! 643: php_stream_fill_read_buffer(stream, size TSRMLS_CC);
! 644:
! 645: toread = stream->writepos - stream->readpos;
! 646: if (toread > size) {
! 647: toread = size;
! 648: }
! 649:
! 650: if (toread > 0) {
! 651: memcpy(buf, stream->readbuf + stream->readpos, toread);
! 652: stream->readpos += toread;
! 653: }
! 654: }
! 655: if (toread > 0) {
! 656: didread += toread;
! 657: buf += toread;
! 658: size -= toread;
! 659: } else {
! 660: /* EOF, or temporary end of data (for non-blocking mode). */
! 661: break;
! 662: }
! 663:
! 664: /* just break anyway, to avoid greedy read */
! 665: if (stream->wrapper != &php_plain_files_wrapper) {
! 666: break;
! 667: }
! 668: }
! 669:
! 670: if (didread > 0) {
! 671: stream->position += didread;
! 672: }
! 673:
! 674: return didread;
! 675: }
! 676:
! 677: PHPAPI int _php_stream_eof(php_stream *stream TSRMLS_DC)
! 678: {
! 679: /* if there is data in the buffer, it's not EOF */
! 680: if (stream->writepos - stream->readpos > 0) {
! 681: return 0;
! 682: }
! 683:
! 684: /* use the configured timeout when checking eof */
! 685: if (!stream->eof && PHP_STREAM_OPTION_RETURN_ERR ==
! 686: php_stream_set_option(stream, PHP_STREAM_OPTION_CHECK_LIVENESS,
! 687: 0, NULL)) {
! 688: stream->eof = 1;
! 689: }
! 690:
! 691: return stream->eof;
! 692: }
! 693:
! 694: PHPAPI int _php_stream_putc(php_stream *stream, int c TSRMLS_DC)
! 695: {
! 696: unsigned char buf = c;
! 697:
! 698: if (php_stream_write(stream, &buf, 1) > 0) {
! 699: return 1;
! 700: }
! 701: return EOF;
! 702: }
! 703:
! 704: PHPAPI int _php_stream_getc(php_stream *stream TSRMLS_DC)
! 705: {
! 706: char buf;
! 707:
! 708: if (php_stream_read(stream, &buf, 1) > 0) {
! 709: return buf & 0xff;
! 710: }
! 711: return EOF;
! 712: }
! 713:
! 714: PHPAPI int _php_stream_puts(php_stream *stream, char *buf TSRMLS_DC)
! 715: {
! 716: int len;
! 717: char newline[2] = "\n"; /* is this OK for Win? */
! 718: len = strlen(buf);
! 719:
! 720: if (len > 0 && php_stream_write(stream, buf, len) && php_stream_write(stream, newline, 1)) {
! 721: return 1;
! 722: }
! 723: return 0;
! 724: }
! 725:
! 726: PHPAPI int _php_stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
! 727: {
! 728: memset(ssb, 0, sizeof(*ssb));
! 729:
! 730: /* if the stream was wrapped, allow the wrapper to stat it */
! 731: if (stream->wrapper && stream->wrapper->wops->stream_stat != NULL) {
! 732: return stream->wrapper->wops->stream_stat(stream->wrapper, stream, ssb TSRMLS_CC);
! 733: }
! 734:
! 735: /* if the stream doesn't directly support stat-ing, return with failure.
! 736: * We could try and emulate this by casting to a FD and fstat-ing it,
! 737: * but since the fd might not represent the actual underlying content
! 738: * this would give bogus results. */
! 739: if (stream->ops->stat == NULL) {
! 740: return -1;
! 741: }
! 742:
! 743: return (stream->ops->stat)(stream, ssb TSRMLS_CC);
! 744: }
! 745:
! 746: PHPAPI char *php_stream_locate_eol(php_stream *stream, char *buf, size_t buf_len TSRMLS_DC)
! 747: {
! 748: size_t avail;
! 749: char *cr, *lf, *eol = NULL;
! 750: char *readptr;
! 751:
! 752: if (!buf) {
! 753: readptr = stream->readbuf + stream->readpos;
! 754: avail = stream->writepos - stream->readpos;
! 755: } else {
! 756: readptr = buf;
! 757: avail = buf_len;
! 758: }
! 759:
! 760: /* Look for EOL */
! 761: if (stream->flags & PHP_STREAM_FLAG_DETECT_EOL) {
! 762: cr = memchr(readptr, '\r', avail);
! 763: lf = memchr(readptr, '\n', avail);
! 764:
! 765: if (cr && lf != cr + 1 && !(lf && lf < cr)) {
! 766: /* mac */
! 767: stream->flags ^= PHP_STREAM_FLAG_DETECT_EOL;
! 768: stream->flags |= PHP_STREAM_FLAG_EOL_MAC;
! 769: eol = cr;
! 770: } else if ((cr && lf && cr == lf - 1) || (lf)) {
! 771: /* dos or unix endings */
! 772: stream->flags ^= PHP_STREAM_FLAG_DETECT_EOL;
! 773: eol = lf;
! 774: }
! 775: } else if (stream->flags & PHP_STREAM_FLAG_EOL_MAC) {
! 776: eol = memchr(readptr, '\r', avail);
! 777: } else {
! 778: /* unix (and dos) line endings */
! 779: eol = memchr(readptr, '\n', avail);
! 780: }
! 781:
! 782: return eol;
! 783: }
! 784:
! 785: /* If buf == NULL, the buffer will be allocated automatically and will be of an
! 786: * appropriate length to hold the line, regardless of the line length, memory
! 787: * permitting */
! 788: PHPAPI char *_php_stream_get_line(php_stream *stream, char *buf, size_t maxlen,
! 789: size_t *returned_len TSRMLS_DC)
! 790: {
! 791: size_t avail = 0;
! 792: size_t current_buf_size = 0;
! 793: size_t total_copied = 0;
! 794: int grow_mode = 0;
! 795: char *bufstart = buf;
! 796:
! 797: if (buf == NULL) {
! 798: grow_mode = 1;
! 799: } else if (maxlen == 0) {
! 800: return NULL;
! 801: }
! 802:
! 803: /*
! 804: * If the underlying stream operations block when no new data is readable,
! 805: * we need to take extra precautions.
! 806: *
! 807: * If there is buffered data available, we check for a EOL. If it exists,
! 808: * we pass the data immediately back to the caller. This saves a call
! 809: * to the read implementation and will not block where blocking
! 810: * is not necessary at all.
! 811: *
! 812: * If the stream buffer contains more data than the caller requested,
! 813: * we can also avoid that costly step and simply return that data.
! 814: */
! 815:
! 816: for (;;) {
! 817: avail = stream->writepos - stream->readpos;
! 818:
! 819: if (avail > 0) {
! 820: size_t cpysz = 0;
! 821: char *readptr;
! 822: char *eol;
! 823: int done = 0;
! 824:
! 825: readptr = stream->readbuf + stream->readpos;
! 826: eol = php_stream_locate_eol(stream, NULL, 0 TSRMLS_CC);
! 827:
! 828: if (eol) {
! 829: cpysz = eol - readptr + 1;
! 830: done = 1;
! 831: } else {
! 832: cpysz = avail;
! 833: }
! 834:
! 835: if (grow_mode) {
! 836: /* allow room for a NUL. If this realloc is really a realloc
! 837: * (ie: second time around), we get an extra byte. In most
! 838: * cases, with the default chunk size of 8K, we will only
! 839: * incur that overhead once. When people have lines longer
! 840: * than 8K, we waste 1 byte per additional 8K or so.
! 841: * That seems acceptable to me, to avoid making this code
! 842: * hard to follow */
! 843: bufstart = erealloc(bufstart, current_buf_size + cpysz + 1);
! 844: current_buf_size += cpysz + 1;
! 845: buf = bufstart + total_copied;
! 846: } else {
! 847: if (cpysz >= maxlen - 1) {
! 848: cpysz = maxlen - 1;
! 849: done = 1;
! 850: }
! 851: }
! 852:
! 853: memcpy(buf, readptr, cpysz);
! 854:
! 855: stream->position += cpysz;
! 856: stream->readpos += cpysz;
! 857: buf += cpysz;
! 858: maxlen -= cpysz;
! 859: total_copied += cpysz;
! 860:
! 861: if (done) {
! 862: break;
! 863: }
! 864: } else if (stream->eof) {
! 865: break;
! 866: } else {
! 867: /* XXX: Should be fine to always read chunk_size */
! 868: size_t toread;
! 869:
! 870: if (grow_mode) {
! 871: toread = stream->chunk_size;
! 872: } else {
! 873: toread = maxlen - 1;
! 874: if (toread > stream->chunk_size) {
! 875: toread = stream->chunk_size;
! 876: }
! 877: }
! 878:
! 879: php_stream_fill_read_buffer(stream, toread TSRMLS_CC);
! 880:
! 881: if (stream->writepos - stream->readpos == 0) {
! 882: break;
! 883: }
! 884: }
! 885: }
! 886:
! 887: if (total_copied == 0) {
! 888: if (grow_mode) {
! 889: assert(bufstart == NULL);
! 890: }
! 891: return NULL;
! 892: }
! 893:
! 894: buf[0] = '\0';
! 895: if (returned_len) {
! 896: *returned_len = total_copied;
! 897: }
! 898:
! 899: return bufstart;
! 900: }
! 901:
! 902: PHPAPI char *php_stream_get_record(php_stream *stream, size_t maxlen, size_t *returned_len, char *delim, size_t delim_len TSRMLS_DC)
! 903: {
! 904: char *e, *buf;
! 905: size_t toread, len;
! 906: int skip = 0;
! 907:
! 908: len = stream->writepos - stream->readpos;
! 909:
! 910: /* make sure the stream read buffer has maxlen bytes */
! 911: while (len < maxlen) {
! 912:
! 913: size_t just_read;
! 914: toread = MIN(maxlen - len, stream->chunk_size);
! 915:
! 916: php_stream_fill_read_buffer(stream, len + toread TSRMLS_CC);
! 917:
! 918: just_read = (stream->writepos - stream->readpos) - len;
! 919: len += just_read;
! 920:
! 921: /* Assume the stream is temporarily or permanently out of data */
! 922: if (just_read == 0) {
! 923: break;
! 924: }
! 925: }
! 926:
! 927: if (delim_len == 0 || !delim) {
! 928: toread = maxlen;
! 929: } else {
! 930: size_t seek_len;
! 931:
! 932: /* set the maximum number of bytes we're allowed to read from buffer */
! 933: seek_len = stream->writepos - stream->readpos;
! 934: if (seek_len > maxlen) {
! 935: seek_len = maxlen;
! 936: }
! 937:
! 938: if (delim_len == 1) {
! 939: e = memchr(stream->readbuf + stream->readpos, *delim, seek_len);
! 940: } else {
! 941: e = php_memnstr(stream->readbuf + stream->readpos, delim, delim_len, (stream->readbuf + stream->readpos + seek_len));
! 942: }
! 943:
! 944: if (!e) {
! 945: /* return with error if the delimiter string was not found, we
! 946: * could not completely fill the read buffer with maxlen bytes
! 947: * and we don't know we've reached end of file. Added with
! 948: * non-blocking streams in mind, where this situation is frequent */
! 949: if (seek_len < maxlen && !stream->eof) {
! 950: return NULL;
! 951: }
! 952: toread = maxlen;
! 953: } else {
! 954: toread = e - (char *) stream->readbuf - stream->readpos;
! 955: /* we found the delimiter, so advance the read pointer past it */
! 956: skip = 1;
! 957: }
! 958: }
! 959:
! 960: if (toread > maxlen && maxlen > 0) {
! 961: toread = maxlen;
! 962: }
! 963:
! 964: buf = emalloc(toread + 1);
! 965: *returned_len = php_stream_read(stream, buf, toread);
! 966:
! 967: if (skip) {
! 968: stream->readpos += delim_len;
! 969: stream->position += delim_len;
! 970: }
! 971: buf[*returned_len] = '\0';
! 972: return buf;
! 973: }
! 974:
! 975: /* Writes a buffer directly to a stream, using multiple of the chunk size */
! 976: static size_t _php_stream_write_buffer(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
! 977: {
! 978: size_t didwrite = 0, towrite, justwrote;
! 979:
! 980: /* if we have a seekable stream we need to ensure that data is written at the
! 981: * current stream->position. This means invalidating the read buffer and then
! 982: * performing a low-level seek */
! 983: if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && stream->readpos != stream->writepos) {
! 984: stream->readpos = stream->writepos = 0;
! 985:
! 986: stream->ops->seek(stream, stream->position, SEEK_SET, &stream->position TSRMLS_CC);
! 987: }
! 988:
! 989:
! 990: while (count > 0) {
! 991: towrite = count;
! 992: if (towrite > stream->chunk_size)
! 993: towrite = stream->chunk_size;
! 994:
! 995: justwrote = stream->ops->write(stream, buf, towrite TSRMLS_CC);
! 996:
! 997: /* convert justwrote to an integer, since normally it is unsigned */
! 998: if ((int)justwrote > 0) {
! 999: buf += justwrote;
! 1000: count -= justwrote;
! 1001: didwrite += justwrote;
! 1002:
! 1003: /* Only screw with the buffer if we can seek, otherwise we lose data
! 1004: * buffered from fifos and sockets */
! 1005: if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
! 1006: stream->position += justwrote;
! 1007: }
! 1008: } else {
! 1009: break;
! 1010: }
! 1011: }
! 1012: return didwrite;
! 1013:
! 1014: }
! 1015:
! 1016: /* push some data through the write filter chain.
! 1017: * buf may be NULL, if flags are set to indicate a flush.
! 1018: * This may trigger a real write to the stream.
! 1019: * Returns the number of bytes consumed from buf by the first filter in the chain.
! 1020: * */
! 1021: static size_t _php_stream_write_filtered(php_stream *stream, const char *buf, size_t count, int flags TSRMLS_DC)
! 1022: {
! 1023: size_t consumed = 0;
! 1024: php_stream_bucket *bucket;
! 1025: php_stream_bucket_brigade brig_in = { NULL, NULL }, brig_out = { NULL, NULL };
! 1026: php_stream_bucket_brigade *brig_inp = &brig_in, *brig_outp = &brig_out, *brig_swap;
! 1027: php_stream_filter_status_t status = PSFS_ERR_FATAL;
! 1028: php_stream_filter *filter;
! 1029:
! 1030: if (buf) {
! 1031: bucket = php_stream_bucket_new(stream, (char *)buf, count, 0, 0 TSRMLS_CC);
! 1032: php_stream_bucket_append(&brig_in, bucket TSRMLS_CC);
! 1033: }
! 1034:
! 1035: for (filter = stream->writefilters.head; filter; filter = filter->next) {
! 1036: /* for our return value, we are interested in the number of bytes consumed from
! 1037: * the first filter in the chain */
! 1038: status = filter->fops->filter(stream, filter, brig_inp, brig_outp,
! 1039: filter == stream->writefilters.head ? &consumed : NULL, flags TSRMLS_CC);
! 1040:
! 1041: if (status != PSFS_PASS_ON) {
! 1042: break;
! 1043: }
! 1044: /* brig_out becomes brig_in.
! 1045: * brig_in will always be empty here, as the filter MUST attach any un-consumed buckets
! 1046: * to its own brigade */
! 1047: brig_swap = brig_inp;
! 1048: brig_inp = brig_outp;
! 1049: brig_outp = brig_swap;
! 1050: memset(brig_outp, 0, sizeof(*brig_outp));
! 1051: }
! 1052:
! 1053: switch (status) {
! 1054: case PSFS_PASS_ON:
! 1055: /* filter chain generated some output; push it through to the
! 1056: * underlying stream */
! 1057: while (brig_inp->head) {
! 1058: bucket = brig_inp->head;
! 1059: _php_stream_write_buffer(stream, bucket->buf, bucket->buflen TSRMLS_CC);
! 1060: /* Potential error situation - eg: no space on device. Perhaps we should keep this brigade
! 1061: * hanging around and try to write it later.
! 1062: * At the moment, we just drop it on the floor
! 1063: * */
! 1064:
! 1065: php_stream_bucket_unlink(bucket TSRMLS_CC);
! 1066: php_stream_bucket_delref(bucket TSRMLS_CC);
! 1067: }
! 1068: break;
! 1069: case PSFS_FEED_ME:
! 1070: /* need more data before we can push data through to the stream */
! 1071: break;
! 1072:
! 1073: case PSFS_ERR_FATAL:
! 1074: /* some fatal error. Theoretically, the stream is borked, so all
! 1075: * further writes should fail. */
! 1076: break;
! 1077: }
! 1078:
! 1079: return consumed;
! 1080: }
! 1081:
! 1082: PHPAPI int _php_stream_flush(php_stream *stream, int closing TSRMLS_DC)
! 1083: {
! 1084: int ret = 0;
! 1085:
! 1086: if (stream->writefilters.head) {
! 1087: _php_stream_write_filtered(stream, NULL, 0, closing ? PSFS_FLAG_FLUSH_CLOSE : PSFS_FLAG_FLUSH_INC TSRMLS_CC);
! 1088: }
! 1089:
! 1090: if (stream->ops->flush) {
! 1091: ret = stream->ops->flush(stream TSRMLS_CC);
! 1092: }
! 1093:
! 1094: return ret;
! 1095: }
! 1096:
! 1097: PHPAPI size_t _php_stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
! 1098: {
! 1099: if (buf == NULL || count == 0 || stream->ops->write == NULL) {
! 1100: return 0;
! 1101: }
! 1102:
! 1103: if (stream->writefilters.head) {
! 1104: return _php_stream_write_filtered(stream, buf, count, PSFS_FLAG_NORMAL TSRMLS_CC);
! 1105: } else {
! 1106: return _php_stream_write_buffer(stream, buf, count TSRMLS_CC);
! 1107: }
! 1108: }
! 1109:
! 1110: PHPAPI size_t _php_stream_printf(php_stream *stream TSRMLS_DC, const char *fmt, ...)
! 1111: {
! 1112: size_t count;
! 1113: char *buf;
! 1114: va_list ap;
! 1115:
! 1116: va_start(ap, fmt);
! 1117: count = vspprintf(&buf, 0, fmt, ap);
! 1118: va_end(ap);
! 1119:
! 1120: if (!buf) {
! 1121: return 0; /* error condition */
! 1122: }
! 1123:
! 1124: count = php_stream_write(stream, buf, count);
! 1125: efree(buf);
! 1126:
! 1127: return count;
! 1128: }
! 1129:
! 1130: PHPAPI off_t _php_stream_tell(php_stream *stream TSRMLS_DC)
! 1131: {
! 1132: return stream->position;
! 1133: }
! 1134:
! 1135: PHPAPI int _php_stream_seek(php_stream *stream, off_t offset, int whence TSRMLS_DC)
! 1136: {
! 1137: if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
! 1138: /* flush to commit data written to the fopencookie FILE* */
! 1139: fflush(stream->stdiocast);
! 1140: }
! 1141:
! 1142: /* handle the case where we are in the buffer */
! 1143: if ((stream->flags & PHP_STREAM_FLAG_NO_BUFFER) == 0) {
! 1144: switch(whence) {
! 1145: case SEEK_CUR:
! 1146: if (offset > 0 && offset <= stream->writepos - stream->readpos) {
! 1147: stream->readpos += offset; /* if offset = ..., then readpos = writepos */
! 1148: stream->position += offset;
! 1149: stream->eof = 0;
! 1150: return 0;
! 1151: }
! 1152: break;
! 1153: case SEEK_SET:
! 1154: if (offset > stream->position &&
! 1155: offset <= stream->position + stream->writepos - stream->readpos) {
! 1156: stream->readpos += offset - stream->position;
! 1157: stream->position = offset;
! 1158: stream->eof = 0;
! 1159: return 0;
! 1160: }
! 1161: break;
! 1162: }
! 1163: }
! 1164:
! 1165:
! 1166: if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
! 1167: int ret;
! 1168:
! 1169: if (stream->writefilters.head) {
! 1170: _php_stream_flush(stream, 0 TSRMLS_CC);
! 1171: }
! 1172:
! 1173: switch(whence) {
! 1174: case SEEK_CUR:
! 1175: offset = stream->position + offset;
! 1176: whence = SEEK_SET;
! 1177: break;
! 1178: }
! 1179: ret = stream->ops->seek(stream, offset, whence, &stream->position TSRMLS_CC);
! 1180:
! 1181: if (((stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) || ret == 0) {
! 1182: if (ret == 0) {
! 1183: stream->eof = 0;
! 1184: }
! 1185:
! 1186: /* invalidate the buffer contents */
! 1187: stream->readpos = stream->writepos = 0;
! 1188:
! 1189: return ret;
! 1190: }
! 1191: /* else the stream has decided that it can't support seeking after all;
! 1192: * fall through to attempt emulation */
! 1193: }
! 1194:
! 1195: /* emulate forward moving seeks with reads */
! 1196: if (whence == SEEK_CUR && offset >= 0) {
! 1197: char tmp[1024];
! 1198: size_t didread;
! 1199: while(offset > 0) {
! 1200: if ((didread = php_stream_read(stream, tmp, MIN(offset, sizeof(tmp)))) == 0) {
! 1201: return -1;
! 1202: }
! 1203: offset -= didread;
! 1204: }
! 1205: stream->eof = 0;
! 1206: return 0;
! 1207: }
! 1208:
! 1209: php_error_docref(NULL TSRMLS_CC, E_WARNING, "stream does not support seeking");
! 1210:
! 1211: return -1;
! 1212: }
! 1213:
! 1214: PHPAPI int _php_stream_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
! 1215: {
! 1216: int ret = PHP_STREAM_OPTION_RETURN_NOTIMPL;
! 1217:
! 1218: if (stream->ops->set_option) {
! 1219: ret = stream->ops->set_option(stream, option, value, ptrparam TSRMLS_CC);
! 1220: }
! 1221:
! 1222: if (ret == PHP_STREAM_OPTION_RETURN_NOTIMPL) {
! 1223: switch(option) {
! 1224: case PHP_STREAM_OPTION_SET_CHUNK_SIZE:
! 1225: ret = stream->chunk_size;
! 1226: stream->chunk_size = value;
! 1227: return ret;
! 1228:
! 1229: case PHP_STREAM_OPTION_READ_BUFFER:
! 1230: /* try to match the buffer mode as best we can */
! 1231: if (value == PHP_STREAM_BUFFER_NONE) {
! 1232: stream->flags |= PHP_STREAM_FLAG_NO_BUFFER;
! 1233: } else if (stream->flags & PHP_STREAM_FLAG_NO_BUFFER) {
! 1234: stream->flags ^= PHP_STREAM_FLAG_NO_BUFFER;
! 1235: }
! 1236: ret = PHP_STREAM_OPTION_RETURN_OK;
! 1237: break;
! 1238:
! 1239: default:
! 1240: ;
! 1241: }
! 1242: }
! 1243:
! 1244: return ret;
! 1245: }
! 1246:
! 1247: PHPAPI int _php_stream_truncate_set_size(php_stream *stream, size_t newsize TSRMLS_DC)
! 1248: {
! 1249: return php_stream_set_option(stream, PHP_STREAM_OPTION_TRUNCATE_API, PHP_STREAM_TRUNCATE_SET_SIZE, &newsize);
! 1250: }
! 1251:
! 1252: PHPAPI size_t _php_stream_passthru(php_stream * stream STREAMS_DC TSRMLS_DC)
! 1253: {
! 1254: size_t bcount = 0;
! 1255: char buf[8192];
! 1256: int b;
! 1257:
! 1258: if (php_stream_mmap_possible(stream)) {
! 1259: char *p;
! 1260: size_t mapped;
! 1261:
! 1262: p = php_stream_mmap_range(stream, php_stream_tell(stream), PHP_STREAM_MMAP_ALL, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped);
! 1263:
! 1264: if (p) {
! 1265: PHPWRITE(p, mapped);
! 1266:
! 1267: php_stream_mmap_unmap_ex(stream, mapped);
! 1268:
! 1269: return mapped;
! 1270: }
! 1271: }
! 1272:
! 1273: while ((b = php_stream_read(stream, buf, sizeof(buf))) > 0) {
! 1274: PHPWRITE(buf, b);
! 1275: bcount += b;
! 1276: }
! 1277:
! 1278: return bcount;
! 1279: }
! 1280:
! 1281:
! 1282: PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen, int persistent STREAMS_DC TSRMLS_DC)
! 1283: {
! 1284: size_t ret = 0;
! 1285: char *ptr;
! 1286: size_t len = 0, max_len;
! 1287: int step = CHUNK_SIZE;
! 1288: int min_room = CHUNK_SIZE / 4;
! 1289: php_stream_statbuf ssbuf;
! 1290:
! 1291: if (maxlen == 0) {
! 1292: return 0;
! 1293: }
! 1294:
! 1295: if (maxlen == PHP_STREAM_COPY_ALL) {
! 1296: maxlen = 0;
! 1297: }
! 1298:
! 1299: if (maxlen > 0) {
! 1300: ptr = *buf = pemalloc_rel_orig(maxlen + 1, persistent);
! 1301: while ((len < maxlen) && !php_stream_eof(src)) {
! 1302: ret = php_stream_read(src, ptr, maxlen - len);
! 1303: if (!ret) {
! 1304: break;
! 1305: }
! 1306: len += ret;
! 1307: ptr += ret;
! 1308: }
! 1309: *ptr = '\0';
! 1310: return len;
! 1311: }
! 1312:
! 1313: /* avoid many reallocs by allocating a good sized chunk to begin with, if
! 1314: * we can. Note that the stream may be filtered, in which case the stat
! 1315: * result may be inaccurate, as the filter may inflate or deflate the
! 1316: * number of bytes that we can read. In order to avoid an upsize followed
! 1317: * by a downsize of the buffer, overestimate by the step size (which is
! 1318: * 2K). */
! 1319: if (php_stream_stat(src, &ssbuf) == 0 && ssbuf.sb.st_size > 0) {
! 1320: max_len = ssbuf.sb.st_size + step;
! 1321: } else {
! 1322: max_len = step;
! 1323: }
! 1324:
! 1325: ptr = *buf = pemalloc_rel_orig(max_len, persistent);
! 1326:
! 1327: while((ret = php_stream_read(src, ptr, max_len - len))) {
! 1328: len += ret;
! 1329: if (len + min_room >= max_len) {
! 1330: *buf = perealloc_rel_orig(*buf, max_len + step, persistent);
! 1331: max_len += step;
! 1332: ptr = *buf + len;
! 1333: } else {
! 1334: ptr += ret;
! 1335: }
! 1336: }
! 1337: if (len) {
! 1338: *buf = perealloc_rel_orig(*buf, len + 1, persistent);
! 1339: (*buf)[len] = '\0';
! 1340: } else {
! 1341: pefree(*buf, persistent);
! 1342: *buf = NULL;
! 1343: }
! 1344: return len;
! 1345: }
! 1346:
! 1347: /* Returns SUCCESS/FAILURE and sets *len to the number of bytes moved */
! 1348: PHPAPI size_t _php_stream_copy_to_stream_ex(php_stream *src, php_stream *dest, size_t maxlen, size_t *len STREAMS_DC TSRMLS_DC)
! 1349: {
! 1350: char buf[CHUNK_SIZE];
! 1351: size_t readchunk;
! 1352: size_t haveread = 0;
! 1353: size_t didread;
! 1354: size_t dummy;
! 1355: php_stream_statbuf ssbuf;
! 1356:
! 1357: if (!len) {
! 1358: len = &dummy;
! 1359: }
! 1360:
! 1361: if (maxlen == 0) {
! 1362: *len = 0;
! 1363: return SUCCESS;
! 1364: }
! 1365:
! 1366: if (maxlen == PHP_STREAM_COPY_ALL) {
! 1367: maxlen = 0;
! 1368: }
! 1369:
! 1370: if (php_stream_stat(src, &ssbuf) == 0) {
! 1371: if (ssbuf.sb.st_size == 0
! 1372: #ifdef S_ISREG
! 1373: && S_ISREG(ssbuf.sb.st_mode)
! 1374: #endif
! 1375: ) {
! 1376: *len = 0;
! 1377: return SUCCESS;
! 1378: }
! 1379: }
! 1380:
! 1381: if (php_stream_mmap_possible(src)) {
! 1382: char *p;
! 1383: size_t mapped;
! 1384:
! 1385: p = php_stream_mmap_range(src, php_stream_tell(src), maxlen, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped);
! 1386:
! 1387: if (p) {
! 1388: mapped = php_stream_write(dest, p, mapped);
! 1389:
! 1390: php_stream_mmap_unmap_ex(src, mapped);
! 1391:
! 1392: *len = mapped;
! 1393:
! 1394: /* we've got at least 1 byte to read.
! 1395: * less than 1 is an error */
! 1396:
! 1397: if (mapped > 0) {
! 1398: return SUCCESS;
! 1399: }
! 1400: return FAILURE;
! 1401: }
! 1402: }
! 1403:
! 1404: while(1) {
! 1405: readchunk = sizeof(buf);
! 1406:
! 1407: if (maxlen && (maxlen - haveread) < readchunk) {
! 1408: readchunk = maxlen - haveread;
! 1409: }
! 1410:
! 1411: didread = php_stream_read(src, buf, readchunk);
! 1412:
! 1413: if (didread) {
! 1414: /* extra paranoid */
! 1415: size_t didwrite, towrite;
! 1416: char *writeptr;
! 1417:
! 1418: towrite = didread;
! 1419: writeptr = buf;
! 1420: haveread += didread;
! 1421:
! 1422: while(towrite) {
! 1423: didwrite = php_stream_write(dest, writeptr, towrite);
! 1424: if (didwrite == 0) {
! 1425: *len = haveread - (didread - towrite);
! 1426: return FAILURE;
! 1427: }
! 1428:
! 1429: towrite -= didwrite;
! 1430: writeptr += didwrite;
! 1431: }
! 1432: } else {
! 1433: break;
! 1434: }
! 1435:
! 1436: if (maxlen - haveread == 0) {
! 1437: break;
! 1438: }
! 1439: }
! 1440:
! 1441: *len = haveread;
! 1442:
! 1443: /* we've got at least 1 byte to read.
! 1444: * less than 1 is an error */
! 1445:
! 1446: if (haveread > 0 || src->eof) {
! 1447: return SUCCESS;
! 1448: }
! 1449: return FAILURE;
! 1450: }
! 1451:
! 1452: /* Returns the number of bytes moved.
! 1453: * Returns 1 when source len is 0.
! 1454: * Deprecated in favor of php_stream_copy_to_stream_ex() */
! 1455: ZEND_ATTRIBUTE_DEPRECATED
! 1456: PHPAPI size_t _php_stream_copy_to_stream(php_stream *src, php_stream *dest, size_t maxlen STREAMS_DC TSRMLS_DC)
! 1457: {
! 1458: size_t len;
! 1459: int ret = _php_stream_copy_to_stream_ex(src, dest, maxlen, &len STREAMS_REL_CC TSRMLS_CC);
! 1460: if (ret == SUCCESS && len == 0 && maxlen != 0) {
! 1461: return 1;
! 1462: }
! 1463: return len;
! 1464: }
! 1465: /* }}} */
! 1466:
! 1467: /* {{{ wrapper init and registration */
! 1468:
! 1469: static void stream_resource_regular_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
! 1470: {
! 1471: php_stream *stream = (php_stream*)rsrc->ptr;
! 1472: /* set the return value for pclose */
! 1473: FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
! 1474: }
! 1475:
! 1476: static void stream_resource_persistent_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
! 1477: {
! 1478: php_stream *stream = (php_stream*)rsrc->ptr;
! 1479: FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
! 1480: }
! 1481:
! 1482: void php_shutdown_stream_hashes(TSRMLS_D)
! 1483: {
! 1484: if (FG(stream_wrappers)) {
! 1485: zend_hash_destroy(FG(stream_wrappers));
! 1486: efree(FG(stream_wrappers));
! 1487: FG(stream_wrappers) = NULL;
! 1488: }
! 1489:
! 1490: if (FG(stream_filters)) {
! 1491: zend_hash_destroy(FG(stream_filters));
! 1492: efree(FG(stream_filters));
! 1493: FG(stream_filters) = NULL;
! 1494: }
! 1495: }
! 1496:
! 1497: int php_init_stream_wrappers(int module_number TSRMLS_DC)
! 1498: {
! 1499: le_stream = zend_register_list_destructors_ex(stream_resource_regular_dtor, NULL, "stream", module_number);
! 1500: le_pstream = zend_register_list_destructors_ex(NULL, stream_resource_persistent_dtor, "persistent stream", module_number);
! 1501:
! 1502: /* Filters are cleaned up by the streams they're attached to */
! 1503: le_stream_filter = zend_register_list_destructors_ex(NULL, NULL, "stream filter", module_number);
! 1504:
! 1505: return (
! 1506: zend_hash_init(&url_stream_wrappers_hash, 0, NULL, NULL, 1) == SUCCESS
! 1507: &&
! 1508: zend_hash_init(php_get_stream_filters_hash_global(), 0, NULL, NULL, 1) == SUCCESS
! 1509: &&
! 1510: zend_hash_init(php_stream_xport_get_hash(), 0, NULL, NULL, 1) == SUCCESS
! 1511: &&
! 1512: php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
! 1513: &&
! 1514: php_stream_xport_register("udp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
! 1515: #if defined(AF_UNIX) && !(defined(PHP_WIN32) || defined(__riscos__) || defined(NETWARE))
! 1516: &&
! 1517: php_stream_xport_register("unix", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
! 1518: &&
! 1519: php_stream_xport_register("udg", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
! 1520: #endif
! 1521: ) ? SUCCESS : FAILURE;
! 1522: }
! 1523:
! 1524: int php_shutdown_stream_wrappers(int module_number TSRMLS_DC)
! 1525: {
! 1526: zend_hash_destroy(&url_stream_wrappers_hash);
! 1527: zend_hash_destroy(php_get_stream_filters_hash_global());
! 1528: zend_hash_destroy(php_stream_xport_get_hash());
! 1529: return SUCCESS;
! 1530: }
! 1531:
! 1532: /* Validate protocol scheme names during registration
! 1533: * Must conform to /^[a-zA-Z0-9+.-]+$/
! 1534: */
! 1535: static inline int php_stream_wrapper_scheme_validate(char *protocol, int protocol_len)
! 1536: {
! 1537: int i;
! 1538:
! 1539: for(i = 0; i < protocol_len; i++) {
! 1540: if (!isalnum((int)protocol[i]) &&
! 1541: protocol[i] != '+' &&
! 1542: protocol[i] != '-' &&
! 1543: protocol[i] != '.') {
! 1544: return FAILURE;
! 1545: }
! 1546: }
! 1547:
! 1548: return SUCCESS;
! 1549: }
! 1550:
! 1551: /* API for registering GLOBAL wrappers */
! 1552: PHPAPI int php_register_url_stream_wrapper(char *protocol, php_stream_wrapper *wrapper TSRMLS_DC)
! 1553: {
! 1554: int protocol_len = strlen(protocol);
! 1555:
! 1556: if (php_stream_wrapper_scheme_validate(protocol, protocol_len) == FAILURE) {
! 1557: return FAILURE;
! 1558: }
! 1559:
! 1560: return zend_hash_add(&url_stream_wrappers_hash, protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
! 1561: }
! 1562:
! 1563: PHPAPI int php_unregister_url_stream_wrapper(char *protocol TSRMLS_DC)
! 1564: {
! 1565: return zend_hash_del(&url_stream_wrappers_hash, protocol, strlen(protocol) + 1);
! 1566: }
! 1567:
! 1568: static void clone_wrapper_hash(TSRMLS_D)
! 1569: {
! 1570: php_stream_wrapper *tmp;
! 1571:
! 1572: ALLOC_HASHTABLE(FG(stream_wrappers));
! 1573: zend_hash_init(FG(stream_wrappers), zend_hash_num_elements(&url_stream_wrappers_hash), NULL, NULL, 1);
! 1574: zend_hash_copy(FG(stream_wrappers), &url_stream_wrappers_hash, NULL, &tmp, sizeof(tmp));
! 1575: }
! 1576:
! 1577: /* API for registering VOLATILE wrappers */
! 1578: PHPAPI int php_register_url_stream_wrapper_volatile(char *protocol, php_stream_wrapper *wrapper TSRMLS_DC)
! 1579: {
! 1580: int protocol_len = strlen(protocol);
! 1581:
! 1582: if (php_stream_wrapper_scheme_validate(protocol, protocol_len) == FAILURE) {
! 1583: return FAILURE;
! 1584: }
! 1585:
! 1586: if (!FG(stream_wrappers)) {
! 1587: clone_wrapper_hash(TSRMLS_C);
! 1588: }
! 1589:
! 1590: return zend_hash_add(FG(stream_wrappers), protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
! 1591: }
! 1592:
! 1593: PHPAPI int php_unregister_url_stream_wrapper_volatile(char *protocol TSRMLS_DC)
! 1594: {
! 1595: if (!FG(stream_wrappers)) {
! 1596: clone_wrapper_hash(TSRMLS_C);
! 1597: }
! 1598:
! 1599: return zend_hash_del(FG(stream_wrappers), protocol, strlen(protocol) + 1);
! 1600: }
! 1601: /* }}} */
! 1602:
! 1603: /* {{{ php_stream_locate_url_wrapper */
! 1604: PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, char **path_for_open, int options TSRMLS_DC)
! 1605: {
! 1606: HashTable *wrapper_hash = (FG(stream_wrappers) ? FG(stream_wrappers) : &url_stream_wrappers_hash);
! 1607: php_stream_wrapper **wrapperpp = NULL;
! 1608: const char *p, *protocol = NULL;
! 1609: int n = 0;
! 1610:
! 1611: if (path_for_open) {
! 1612: *path_for_open = (char*)path;
! 1613: }
! 1614:
! 1615: if (options & IGNORE_URL) {
! 1616: return (options & STREAM_LOCATE_WRAPPERS_ONLY) ? NULL : &php_plain_files_wrapper;
! 1617: }
! 1618:
! 1619: for (p = path; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; p++) {
! 1620: n++;
! 1621: }
! 1622:
! 1623: if ((*p == ':') && (n > 1) && (!strncmp("//", p+1, 2) || (n == 4 && !memcmp("data:", path, 5)))) {
! 1624: protocol = path;
! 1625: } else if (n == 5 && strncasecmp(path, "zlib:", 5) == 0) {
! 1626: /* BC with older php scripts and zlib wrapper */
! 1627: protocol = "compress.zlib";
! 1628: n = 13;
! 1629: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Use of \"zlib:\" wrapper is deprecated; please use \"compress.zlib://\" instead");
! 1630: }
! 1631:
! 1632: if (protocol) {
! 1633: char *tmp = estrndup(protocol, n);
! 1634: if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
! 1635: php_strtolower(tmp, n);
! 1636: if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
! 1637: char wrapper_name[32];
! 1638:
! 1639: if (n >= sizeof(wrapper_name)) {
! 1640: n = sizeof(wrapper_name) - 1;
! 1641: }
! 1642: PHP_STRLCPY(wrapper_name, protocol, sizeof(wrapper_name), n);
! 1643:
! 1644: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find the wrapper \"%s\" - did you forget to enable it when you configured PHP?", wrapper_name);
! 1645:
! 1646: wrapperpp = NULL;
! 1647: protocol = NULL;
! 1648: }
! 1649: }
! 1650: efree(tmp);
! 1651: }
! 1652: /* TODO: curl based streams probably support file:// properly */
! 1653: if (!protocol || !strncasecmp(protocol, "file", n)) {
! 1654: /* fall back on regular file access */
! 1655: php_stream_wrapper *plain_files_wrapper = &php_plain_files_wrapper;
! 1656:
! 1657: if (protocol) {
! 1658: int localhost = 0;
! 1659:
! 1660: if (!strncasecmp(path, "file://localhost/", 17)) {
! 1661: localhost = 1;
! 1662: }
! 1663:
! 1664: #ifdef PHP_WIN32
! 1665: if (localhost == 0 && path[n+3] != '\0' && path[n+3] != '/' && path[n+4] != ':') {
! 1666: #else
! 1667: if (localhost == 0 && path[n+3] != '\0' && path[n+3] != '/') {
! 1668: #endif
! 1669: if (options & REPORT_ERRORS) {
! 1670: php_error_docref(NULL TSRMLS_CC, E_WARNING, "remote host file access not supported, %s", path);
! 1671: }
! 1672: return NULL;
! 1673: }
! 1674:
! 1675: if (path_for_open) {
! 1676: /* skip past protocol and :/, but handle windows correctly */
! 1677: *path_for_open = (char*)path + n + 1;
! 1678: if (localhost == 1) {
! 1679: (*path_for_open) += 11;
! 1680: }
! 1681: while (*(++*path_for_open)=='/');
! 1682: #ifdef PHP_WIN32
! 1683: if (*(*path_for_open + 1) != ':')
! 1684: #endif
! 1685: (*path_for_open)--;
! 1686: }
! 1687: }
! 1688:
! 1689: if (options & STREAM_LOCATE_WRAPPERS_ONLY) {
! 1690: return NULL;
! 1691: }
! 1692:
! 1693: if (FG(stream_wrappers)) {
! 1694: /* The file:// wrapper may have been disabled/overridden */
! 1695:
! 1696: if (wrapperpp) {
! 1697: /* It was found so go ahead and provide it */
! 1698: return *wrapperpp;
! 1699: }
! 1700:
! 1701: /* Check again, the original check might have not known the protocol name */
! 1702: if (zend_hash_find(wrapper_hash, "file", sizeof("file"), (void**)&wrapperpp) == SUCCESS) {
! 1703: return *wrapperpp;
! 1704: }
! 1705:
! 1706: if (options & REPORT_ERRORS) {
! 1707: php_error_docref(NULL TSRMLS_CC, E_WARNING, "file:// wrapper is disabled in the server configuration");
! 1708: }
! 1709: return NULL;
! 1710: }
! 1711:
! 1712: return plain_files_wrapper;
! 1713: }
! 1714:
! 1715: if (wrapperpp && (*wrapperpp)->is_url &&
! 1716: (options & STREAM_DISABLE_URL_PROTECTION) == 0 &&
! 1717: (!PG(allow_url_fopen) ||
! 1718: (((options & STREAM_OPEN_FOR_INCLUDE) ||
! 1719: PG(in_user_include)) && !PG(allow_url_include)))) {
! 1720: if (options & REPORT_ERRORS) {
! 1721: /* protocol[n] probably isn't '\0' */
! 1722: char *protocol_dup = estrndup(protocol, n);
! 1723: if (!PG(allow_url_fopen)) {
! 1724: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// wrapper is disabled in the server configuration by allow_url_fopen=0", protocol_dup);
! 1725: } else {
! 1726: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// wrapper is disabled in the server configuration by allow_url_include=0", protocol_dup);
! 1727: }
! 1728: efree(protocol_dup);
! 1729: }
! 1730: return NULL;
! 1731: }
! 1732:
! 1733: return *wrapperpp;
! 1734: }
! 1735: /* }}} */
! 1736:
! 1737: /* {{{ _php_stream_mkdir
! 1738: */
! 1739: PHPAPI int _php_stream_mkdir(char *path, int mode, int options, php_stream_context *context TSRMLS_DC)
! 1740: {
! 1741: php_stream_wrapper *wrapper = NULL;
! 1742:
! 1743: wrapper = php_stream_locate_url_wrapper(path, NULL, ENFORCE_SAFE_MODE TSRMLS_CC);
! 1744: if (!wrapper || !wrapper->wops || !wrapper->wops->stream_mkdir) {
! 1745: return 0;
! 1746: }
! 1747:
! 1748: return wrapper->wops->stream_mkdir(wrapper, path, mode, options, context TSRMLS_CC);
! 1749: }
! 1750: /* }}} */
! 1751:
! 1752: /* {{{ _php_stream_rmdir
! 1753: */
! 1754: PHPAPI int _php_stream_rmdir(char *path, int options, php_stream_context *context TSRMLS_DC)
! 1755: {
! 1756: php_stream_wrapper *wrapper = NULL;
! 1757:
! 1758: wrapper = php_stream_locate_url_wrapper(path, NULL, ENFORCE_SAFE_MODE TSRMLS_CC);
! 1759: if (!wrapper || !wrapper->wops || !wrapper->wops->stream_rmdir) {
! 1760: return 0;
! 1761: }
! 1762:
! 1763: return wrapper->wops->stream_rmdir(wrapper, path, options, context TSRMLS_CC);
! 1764: }
! 1765: /* }}} */
! 1766:
! 1767: /* {{{ _php_stream_stat_path */
! 1768: PHPAPI int _php_stream_stat_path(char *path, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
! 1769: {
! 1770: php_stream_wrapper *wrapper = NULL;
! 1771: char *path_to_open = path;
! 1772: int ret;
! 1773:
! 1774: /* Try to hit the cache first */
! 1775: if (flags & PHP_STREAM_URL_STAT_LINK) {
! 1776: if (BG(CurrentLStatFile) && strcmp(path, BG(CurrentLStatFile)) == 0) {
! 1777: memcpy(ssb, &BG(lssb), sizeof(php_stream_statbuf));
! 1778: return 0;
! 1779: }
! 1780: } else {
! 1781: if (BG(CurrentStatFile) && strcmp(path, BG(CurrentStatFile)) == 0) {
! 1782: memcpy(ssb, &BG(ssb), sizeof(php_stream_statbuf));
! 1783: return 0;
! 1784: }
! 1785: }
! 1786:
! 1787: wrapper = php_stream_locate_url_wrapper(path, &path_to_open, ENFORCE_SAFE_MODE TSRMLS_CC);
! 1788: if (wrapper && wrapper->wops->url_stat) {
! 1789: ret = wrapper->wops->url_stat(wrapper, path_to_open, flags, ssb, context TSRMLS_CC);
! 1790: if (ret == 0) {
! 1791: /* Drop into cache */
! 1792: if (flags & PHP_STREAM_URL_STAT_LINK) {
! 1793: if (BG(CurrentLStatFile)) {
! 1794: efree(BG(CurrentLStatFile));
! 1795: }
! 1796: BG(CurrentLStatFile) = estrdup(path);
! 1797: memcpy(&BG(lssb), ssb, sizeof(php_stream_statbuf));
! 1798: } else {
! 1799: if (BG(CurrentStatFile)) {
! 1800: efree(BG(CurrentStatFile));
! 1801: }
! 1802: BG(CurrentStatFile) = estrdup(path);
! 1803: memcpy(&BG(ssb), ssb, sizeof(php_stream_statbuf));
! 1804: }
! 1805: }
! 1806: return ret;
! 1807: }
! 1808: return -1;
! 1809: }
! 1810: /* }}} */
! 1811:
! 1812: /* {{{ php_stream_opendir */
! 1813: PHPAPI php_stream *_php_stream_opendir(char *path, int options,
! 1814: php_stream_context *context STREAMS_DC TSRMLS_DC)
! 1815: {
! 1816: php_stream *stream = NULL;
! 1817: php_stream_wrapper *wrapper = NULL;
! 1818: char *path_to_open;
! 1819:
! 1820: if (!path || !*path) {
! 1821: return NULL;
! 1822: }
! 1823:
! 1824: path_to_open = path;
! 1825:
! 1826: wrapper = php_stream_locate_url_wrapper(path, &path_to_open, options TSRMLS_CC);
! 1827:
! 1828: if (wrapper && wrapper->wops->dir_opener) {
! 1829: stream = wrapper->wops->dir_opener(wrapper,
! 1830: path_to_open, "r", options ^ REPORT_ERRORS, NULL,
! 1831: context STREAMS_REL_CC TSRMLS_CC);
! 1832:
! 1833: if (stream) {
! 1834: stream->wrapper = wrapper;
! 1835: stream->flags |= PHP_STREAM_FLAG_NO_BUFFER | PHP_STREAM_FLAG_IS_DIR;
! 1836: }
! 1837: } else if (wrapper) {
! 1838: php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC, "not implemented");
! 1839: }
! 1840: if (stream == NULL && (options & REPORT_ERRORS)) {
! 1841: php_stream_display_wrapper_errors(wrapper, path, "failed to open dir" TSRMLS_CC);
! 1842: }
! 1843: php_stream_tidy_wrapper_error_log(wrapper TSRMLS_CC);
! 1844:
! 1845: return stream;
! 1846: }
! 1847: /* }}} */
! 1848:
! 1849: /* {{{ _php_stream_readdir */
! 1850: PHPAPI php_stream_dirent *_php_stream_readdir(php_stream *dirstream, php_stream_dirent *ent TSRMLS_DC)
! 1851: {
! 1852:
! 1853: if (sizeof(php_stream_dirent) == php_stream_read(dirstream, (char*)ent, sizeof(php_stream_dirent))) {
! 1854: return ent;
! 1855: }
! 1856:
! 1857: return NULL;
! 1858: }
! 1859: /* }}} */
! 1860:
! 1861: /* {{{ php_stream_open_wrapper_ex */
! 1862: PHPAPI php_stream *_php_stream_open_wrapper_ex(char *path, char *mode, int options,
! 1863: char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
! 1864: {
! 1865: php_stream *stream = NULL;
! 1866: php_stream_wrapper *wrapper = NULL;
! 1867: char *path_to_open;
! 1868: int persistent = options & STREAM_OPEN_PERSISTENT;
! 1869: char *resolved_path = NULL;
! 1870: char *copy_of_path = NULL;
! 1871:
! 1872:
! 1873: if (opened_path) {
! 1874: *opened_path = NULL;
! 1875: }
! 1876:
! 1877: if (!path || !*path) {
! 1878: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filename cannot be empty");
! 1879: return NULL;
! 1880: }
! 1881:
! 1882: if (options & USE_PATH) {
! 1883: resolved_path = zend_resolve_path(path, strlen(path) TSRMLS_CC);
! 1884: if (resolved_path) {
! 1885: path = resolved_path;
! 1886: /* we've found this file, don't re-check include_path or run realpath */
! 1887: options |= STREAM_ASSUME_REALPATH;
! 1888: options &= ~USE_PATH;
! 1889: }
! 1890: }
! 1891:
! 1892: path_to_open = path;
! 1893:
! 1894: wrapper = php_stream_locate_url_wrapper(path, &path_to_open, options TSRMLS_CC);
! 1895: if (options & STREAM_USE_URL && (!wrapper || !wrapper->is_url)) {
! 1896: php_error_docref(NULL TSRMLS_CC, E_WARNING, "This function may only be used against URLs");
! 1897: if (resolved_path) {
! 1898: efree(resolved_path);
! 1899: }
! 1900: return NULL;
! 1901: }
! 1902:
! 1903: if (wrapper) {
! 1904: if (!wrapper->wops->stream_opener) {
! 1905: php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC,
! 1906: "wrapper does not support stream open");
! 1907: } else {
! 1908: stream = wrapper->wops->stream_opener(wrapper,
! 1909: path_to_open, mode, options ^ REPORT_ERRORS,
! 1910: opened_path, context STREAMS_REL_CC TSRMLS_CC);
! 1911: }
! 1912:
! 1913: /* if the caller asked for a persistent stream but the wrapper did not
! 1914: * return one, force an error here */
! 1915: if (stream && (options & STREAM_OPEN_PERSISTENT) && !stream->is_persistent) {
! 1916: php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC,
! 1917: "wrapper does not support persistent streams");
! 1918: php_stream_close(stream);
! 1919: stream = NULL;
! 1920: }
! 1921:
! 1922: if (stream) {
! 1923: stream->wrapper = wrapper;
! 1924: }
! 1925: }
! 1926:
! 1927: if (stream) {
! 1928: if (opened_path && !*opened_path && resolved_path) {
! 1929: *opened_path = resolved_path;
! 1930: resolved_path = NULL;
! 1931: }
! 1932: if (stream->orig_path) {
! 1933: pefree(stream->orig_path, persistent);
! 1934: }
! 1935: copy_of_path = pestrdup(path, persistent);
! 1936: stream->orig_path = copy_of_path;
! 1937: #if ZEND_DEBUG
! 1938: stream->open_filename = __zend_orig_filename ? __zend_orig_filename : __zend_filename;
! 1939: stream->open_lineno = __zend_orig_lineno ? __zend_orig_lineno : __zend_lineno;
! 1940: #endif
! 1941: }
! 1942:
! 1943: if (stream != NULL && (options & STREAM_MUST_SEEK)) {
! 1944: php_stream *newstream;
! 1945:
! 1946: switch(php_stream_make_seekable_rel(stream, &newstream,
! 1947: (options & STREAM_WILL_CAST)
! 1948: ? PHP_STREAM_PREFER_STDIO : PHP_STREAM_NO_PREFERENCE)) {
! 1949: case PHP_STREAM_UNCHANGED:
! 1950: if (resolved_path) {
! 1951: efree(resolved_path);
! 1952: }
! 1953: return stream;
! 1954: case PHP_STREAM_RELEASED:
! 1955: if (newstream->orig_path) {
! 1956: pefree(newstream->orig_path, persistent);
! 1957: }
! 1958: newstream->orig_path = pestrdup(path, persistent);
! 1959: if (resolved_path) {
! 1960: efree(resolved_path);
! 1961: }
! 1962: return newstream;
! 1963: default:
! 1964: php_stream_close(stream);
! 1965: stream = NULL;
! 1966: if (options & REPORT_ERRORS) {
! 1967: char *tmp = estrdup(path);
! 1968: php_strip_url_passwd(tmp);
! 1969: php_error_docref1(NULL TSRMLS_CC, tmp, E_WARNING, "could not make seekable - %s",
! 1970: tmp);
! 1971: efree(tmp);
! 1972:
! 1973: options ^= REPORT_ERRORS;
! 1974: }
! 1975: }
! 1976: }
! 1977:
! 1978: if (stream && stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && strchr(mode, 'a') && stream->position == 0) {
! 1979: off_t newpos = 0;
! 1980:
! 1981: /* if opened for append, we need to revise our idea of the initial file position */
! 1982: if (0 == stream->ops->seek(stream, 0, SEEK_CUR, &newpos TSRMLS_CC)) {
! 1983: stream->position = newpos;
! 1984: }
! 1985: }
! 1986:
! 1987: if (stream == NULL && (options & REPORT_ERRORS)) {
! 1988: php_stream_display_wrapper_errors(wrapper, path, "failed to open stream" TSRMLS_CC);
! 1989: if (opened_path && *opened_path) {
! 1990: efree(*opened_path);
! 1991: *opened_path = NULL;
! 1992: }
! 1993: }
! 1994: php_stream_tidy_wrapper_error_log(wrapper TSRMLS_CC);
! 1995: #if ZEND_DEBUG
! 1996: if (stream == NULL && copy_of_path != NULL) {
! 1997: pefree(copy_of_path, persistent);
! 1998: }
! 1999: #endif
! 2000: if (resolved_path) {
! 2001: efree(resolved_path);
! 2002: }
! 2003: return stream;
! 2004: }
! 2005: /* }}} */
! 2006:
! 2007: /* {{{ context API */
! 2008: PHPAPI php_stream_context *php_stream_context_set(php_stream *stream, php_stream_context *context)
! 2009: {
! 2010: php_stream_context *oldcontext = stream->context;
! 2011: TSRMLS_FETCH();
! 2012:
! 2013: stream->context = context;
! 2014:
! 2015: if (context) {
! 2016: zend_list_addref(context->rsrc_id);
! 2017: }
! 2018: if (oldcontext) {
! 2019: zend_list_delete(oldcontext->rsrc_id);
! 2020: }
! 2021:
! 2022: return oldcontext;
! 2023: }
! 2024:
! 2025: PHPAPI void php_stream_notification_notify(php_stream_context *context, int notifycode, int severity,
! 2026: char *xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void * ptr TSRMLS_DC)
! 2027: {
! 2028: if (context && context->notifier)
! 2029: context->notifier->func(context, notifycode, severity, xmsg, xcode, bytes_sofar, bytes_max, ptr TSRMLS_CC);
! 2030: }
! 2031:
! 2032: PHPAPI void php_stream_context_free(php_stream_context *context)
! 2033: {
! 2034: if (context->options) {
! 2035: zval_ptr_dtor(&context->options);
! 2036: context->options = NULL;
! 2037: }
! 2038: if (context->notifier) {
! 2039: php_stream_notification_free(context->notifier);
! 2040: context->notifier = NULL;
! 2041: }
! 2042: if (context->links) {
! 2043: zval_ptr_dtor(&context->links);
! 2044: context->links = NULL;
! 2045: }
! 2046: efree(context);
! 2047: }
! 2048:
! 2049: PHPAPI php_stream_context *php_stream_context_alloc(void)
! 2050: {
! 2051: php_stream_context *context;
! 2052:
! 2053: context = ecalloc(1, sizeof(php_stream_context));
! 2054: context->notifier = NULL;
! 2055: MAKE_STD_ZVAL(context->options);
! 2056: array_init(context->options);
! 2057:
! 2058: context->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, context, php_le_stream_context());
! 2059: return context;
! 2060: }
! 2061:
! 2062: PHPAPI php_stream_notifier *php_stream_notification_alloc(void)
! 2063: {
! 2064: return ecalloc(1, sizeof(php_stream_notifier));
! 2065: }
! 2066:
! 2067: PHPAPI void php_stream_notification_free(php_stream_notifier *notifier)
! 2068: {
! 2069: if (notifier->dtor) {
! 2070: notifier->dtor(notifier);
! 2071: }
! 2072: efree(notifier);
! 2073: }
! 2074:
! 2075: PHPAPI int php_stream_context_get_option(php_stream_context *context,
! 2076: const char *wrappername, const char *optionname, zval ***optionvalue)
! 2077: {
! 2078: zval **wrapperhash;
! 2079:
! 2080: if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
! 2081: return FAILURE;
! 2082: }
! 2083: return zend_hash_find(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)optionvalue);
! 2084: }
! 2085:
! 2086: PHPAPI int php_stream_context_set_option(php_stream_context *context,
! 2087: const char *wrappername, const char *optionname, zval *optionvalue)
! 2088: {
! 2089: zval **wrapperhash;
! 2090: zval *category, *copied_val;
! 2091:
! 2092: ALLOC_INIT_ZVAL(copied_val);
! 2093: *copied_val = *optionvalue;
! 2094: zval_copy_ctor(copied_val);
! 2095: INIT_PZVAL(copied_val);
! 2096:
! 2097: if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
! 2098: MAKE_STD_ZVAL(category);
! 2099: array_init(category);
! 2100: if (FAILURE == zend_hash_update(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&category, sizeof(zval *), NULL)) {
! 2101: return FAILURE;
! 2102: }
! 2103:
! 2104: wrapperhash = &category;
! 2105: }
! 2106: return zend_hash_update(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)&copied_val, sizeof(zval *), NULL);
! 2107: }
! 2108:
! 2109: PHPAPI int php_stream_context_get_link(php_stream_context *context,
! 2110: const char *hostent, php_stream **stream)
! 2111: {
! 2112: php_stream **pstream;
! 2113:
! 2114: if (!stream || !hostent || !context || !(context->links)) {
! 2115: return FAILURE;
! 2116: }
! 2117: if (SUCCESS == zend_hash_find(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&pstream)) {
! 2118: *stream = *pstream;
! 2119: return SUCCESS;
! 2120: }
! 2121: return FAILURE;
! 2122: }
! 2123:
! 2124: PHPAPI int php_stream_context_set_link(php_stream_context *context,
! 2125: const char *hostent, php_stream *stream)
! 2126: {
! 2127: if (!context) {
! 2128: return FAILURE;
! 2129: }
! 2130: if (!context->links) {
! 2131: ALLOC_INIT_ZVAL(context->links);
! 2132: array_init(context->links);
! 2133: }
! 2134: if (!stream) {
! 2135: /* Delete any entry for <hostent> */
! 2136: return zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1);
! 2137: }
! 2138: return zend_hash_update(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&stream, sizeof(php_stream *), NULL);
! 2139: }
! 2140:
! 2141: PHPAPI int php_stream_context_del_link(php_stream_context *context,
! 2142: php_stream *stream)
! 2143: {
! 2144: php_stream **pstream;
! 2145: char *hostent;
! 2146: int ret = SUCCESS;
! 2147:
! 2148: if (!context || !context->links || !stream) {
! 2149: return FAILURE;
! 2150: }
! 2151:
! 2152: for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(context->links));
! 2153: SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(context->links), (void**)&pstream);
! 2154: zend_hash_move_forward(Z_ARRVAL_P(context->links))) {
! 2155: if (*pstream == stream) {
! 2156: if (SUCCESS == zend_hash_get_current_key(Z_ARRVAL_P(context->links), &hostent, NULL, 0)) {
! 2157: if (FAILURE == zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1)) {
! 2158: ret = FAILURE;
! 2159: }
! 2160: } else {
! 2161: ret = FAILURE;
! 2162: }
! 2163: }
! 2164: }
! 2165:
! 2166: return ret;
! 2167: }
! 2168: /* }}} */
! 2169:
! 2170: /* {{{ php_stream_dirent_alphasort
! 2171: */
! 2172: PHPAPI int php_stream_dirent_alphasort(const char **a, const char **b)
! 2173: {
! 2174: return strcoll(*a, *b);
! 2175: }
! 2176: /* }}} */
! 2177:
! 2178: /* {{{ php_stream_dirent_alphasortr
! 2179: */
! 2180: PHPAPI int php_stream_dirent_alphasortr(const char **a, const char **b)
! 2181: {
! 2182: return strcoll(*b, *a);
! 2183: }
! 2184: /* }}} */
! 2185:
! 2186: /* {{{ php_stream_scandir
! 2187: */
! 2188: PHPAPI int _php_stream_scandir(char *dirname, char **namelist[], int flags, php_stream_context *context,
! 2189: int (*compare) (const char **a, const char **b) TSRMLS_DC)
! 2190: {
! 2191: php_stream *stream;
! 2192: php_stream_dirent sdp;
! 2193: char **vector = NULL;
! 2194: int vector_size = 0;
! 2195: int nfiles = 0;
! 2196:
! 2197: if (!namelist) {
! 2198: return FAILURE;
! 2199: }
! 2200:
! 2201: stream = php_stream_opendir(dirname, ENFORCE_SAFE_MODE | REPORT_ERRORS, context);
! 2202: if (!stream) {
! 2203: return FAILURE;
! 2204: }
! 2205:
! 2206: while (php_stream_readdir(stream, &sdp)) {
! 2207: if (nfiles == vector_size) {
! 2208: if (vector_size == 0) {
! 2209: vector_size = 10;
! 2210: } else {
! 2211: vector_size *= 2;
! 2212: }
! 2213: vector = (char **) erealloc(vector, vector_size * sizeof(char *));
! 2214: }
! 2215:
! 2216: vector[nfiles] = estrdup(sdp.d_name);
! 2217:
! 2218: nfiles++;
! 2219: }
! 2220: php_stream_closedir(stream);
! 2221:
! 2222: *namelist = vector;
! 2223:
! 2224: if (compare) {
! 2225: qsort(*namelist, nfiles, sizeof(char *), (int(*)(const void *, const void *))compare);
! 2226: }
! 2227: return nfiles;
! 2228: }
! 2229: /* }}} */
! 2230:
! 2231: /*
! 2232: * Local variables:
! 2233: * tab-width: 4
! 2234: * c-basic-offset: 4
! 2235: * End:
! 2236: * vim600: noet sw=4 ts=4 fdm=marker
! 2237: * vim<600: noet sw=4 ts=4
! 2238: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to streams.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / main / streams