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