1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2014 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$ */
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
php_file_le_stream(void)43 PHPAPI int php_file_le_stream(void)
44 {
45 return le_stream;
46 }
47
php_file_le_pstream(void)48 PHPAPI int php_file_le_pstream(void)
49 {
50 return le_pstream;
51 }
52
php_file_le_stream_filter(void)53 PHPAPI int php_file_le_stream_filter(void)
54 {
55 return le_stream_filter;
56 }
57
_php_stream_get_url_stream_wrappers_hash(TSRMLS_D)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
php_stream_get_url_stream_wrappers_hash_global(void)63 PHPAPI HashTable *php_stream_get_url_stream_wrappers_hash_global(void)
64 {
65 return &url_stream_wrappers_hash;
66 }
67
_php_stream_release_context(zend_rsrc_list_entry * le,void * pContext TSRMLS_DC)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
forget_persistent_resource_id_numbers(zend_rsrc_list_entry * rsrc TSRMLS_DC)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
PHP_RSHUTDOWN_FUNCTION(streams)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
php_stream_encloses(php_stream * enclosing,php_stream * enclosed)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
php_stream_from_persistent_id(const char * persistent_id,php_stream ** stream TSRMLS_DC)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
php_get_wrapper_errors_list(php_stream_wrapper * wrapper TSRMLS_DC)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
172 /* {{{ wrapper error reporting */
php_stream_display_wrapper_errors(php_stream_wrapper * wrapper,const char * path,const char * caption TSRMLS_DC)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) {
180 zend_llist *err_list = php_get_wrapper_errors_list(wrapper TSRMLS_CC);
181 if (err_list) {
182 size_t l = 0;
183 int brlen;
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;
189
190 if (PG(html_errors)) {
191 brlen = 7;
192 br = "<br />\n";
193 } else {
194 brlen = 1;
195 br = "\n";
196 }
197
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) {
203 l += brlen;
204 }
205 }
206 msg = emalloc(l + 1);
207 msg[0] = '\0';
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) {
213 strcat(msg, br);
214 }
215 }
216
217 free_msg = 1;
218 } else {
219 if (wrapper == &php_plain_files_wrapper) {
220 msg = strerror(errno); /* TODO: not ts on linux */
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
php_stream_tidy_wrapper_error_log(php_stream_wrapper * wrapper TSRMLS_DC)237 void php_stream_tidy_wrapper_error_log(php_stream_wrapper *wrapper TSRMLS_DC)
238 {
239 if (wrapper && FG(wrapper_errors)) {
240 zend_hash_del(FG(wrapper_errors), (const char*)&wrapper, sizeof wrapper);
241 }
242 }
243
wrapper_error_dtor(void * error)244 static void wrapper_error_dtor(void *error)
245 {
246 efree(*(char**)error);
247 }
248
php_stream_wrapper_log_error(php_stream_wrapper * wrapper,int options TSRMLS_DC,const char * fmt,...)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 {
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);
270 }
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);
281 }
282 }
283
284
285 /* }}} */
286
287 /* allocate a new stream for a particular ops */
_php_stream_alloc(php_stream_ops * ops,void * abstract,const char * persistent_id,const char * mode STREAMS_DC TSRMLS_DC)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
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
345 return ret;
346 }
347 /* }}} */
348
_php_stream_free_enclosed(php_stream * stream_enclosed,int close_options TSRMLS_DC)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
_php_stream_pretty_free_options(int close_options,char * out)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
_php_stream_free_persistent(zend_rsrc_list_entry * le,void * pStream TSRMLS_DC)377 static int _php_stream_free_persistent(zend_rsrc_list_entry *le, void *pStream TSRMLS_DC)
378 {
379 return le->ptr == pStream;
380 }
381
382
_php_stream_free(php_stream * stream,int close_options TSRMLS_DC)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;
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 }
396
397 if (stream->flags & PHP_STREAM_FLAG_NO_CLOSE) {
398 preserve_handle = 1;
399 }
400
401 #if STREAM_DEBUG
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
408 #endif
409
410 if (stream->in_free) {
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 }
417 }
418
419 stream->in_free++;
420
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
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",
456 stream->ops->label, stream, stream->orig_path, preserve_handle, release_cast,
457 (close_options & PHP_STREAM_FREE_RSRC_DTOR) == 0);
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. */
464 if ((close_options & PHP_STREAM_FREE_RSRC_DTOR) == 0) {
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 */
474 if (context && context->links) {
475 php_stream_context_del_link(context, stream);
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
_php_stream_fill_read_buffer(php_stream * stream,size_t size TSRMLS_DC)576 PHPAPI 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
_php_stream_read(php_stream * stream,char * buf,size_t size TSRMLS_DC)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 if (toread == (size_t) -1) {
740 /* e.g. underlying read(2) returned -1 */
741 break;
742 }
743 } else {
744 php_stream_fill_read_buffer(stream, size);
745
746 toread = stream->writepos - stream->readpos;
747 if (toread > size) {
748 toread = size;
749 }
750
751 if (toread > 0) {
752 memcpy(buf, stream->readbuf + stream->readpos, toread);
753 stream->readpos += toread;
754 }
755 }
756 if (toread > 0) {
757 didread += toread;
758 buf += toread;
759 size -= toread;
760 } else {
761 /* EOF, or temporary end of data (for non-blocking mode). */
762 break;
763 }
764
765 /* just break anyway, to avoid greedy read */
766 if (stream->wrapper != &php_plain_files_wrapper) {
767 break;
768 }
769 }
770
771 if (didread > 0) {
772 stream->position += didread;
773 }
774
775 return didread;
776 }
777
_php_stream_eof(php_stream * stream TSRMLS_DC)778 PHPAPI int _php_stream_eof(php_stream *stream TSRMLS_DC)
779 {
780 /* if there is data in the buffer, it's not EOF */
781 if (stream->writepos - stream->readpos > 0) {
782 return 0;
783 }
784
785 /* use the configured timeout when checking eof */
786 if (!stream->eof && PHP_STREAM_OPTION_RETURN_ERR ==
787 php_stream_set_option(stream, PHP_STREAM_OPTION_CHECK_LIVENESS,
788 0, NULL)) {
789 stream->eof = 1;
790 }
791
792 return stream->eof;
793 }
794
_php_stream_putc(php_stream * stream,int c TSRMLS_DC)795 PHPAPI int _php_stream_putc(php_stream *stream, int c TSRMLS_DC)
796 {
797 unsigned char buf = c;
798
799 if (php_stream_write(stream, &buf, 1) > 0) {
800 return 1;
801 }
802 return EOF;
803 }
804
_php_stream_getc(php_stream * stream TSRMLS_DC)805 PHPAPI int _php_stream_getc(php_stream *stream TSRMLS_DC)
806 {
807 char buf;
808
809 if (php_stream_read(stream, &buf, 1) > 0) {
810 return buf & 0xff;
811 }
812 return EOF;
813 }
814
_php_stream_puts(php_stream * stream,char * buf TSRMLS_DC)815 PHPAPI int _php_stream_puts(php_stream *stream, char *buf TSRMLS_DC)
816 {
817 int len;
818 char newline[2] = "\n"; /* is this OK for Win? */
819 len = strlen(buf);
820
821 if (len > 0 && php_stream_write(stream, buf, len) && php_stream_write(stream, newline, 1)) {
822 return 1;
823 }
824 return 0;
825 }
826
_php_stream_stat(php_stream * stream,php_stream_statbuf * ssb TSRMLS_DC)827 PHPAPI int _php_stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
828 {
829 memset(ssb, 0, sizeof(*ssb));
830
831 /* if the stream was wrapped, allow the wrapper to stat it */
832 if (stream->wrapper && stream->wrapper->wops->stream_stat != NULL) {
833 return stream->wrapper->wops->stream_stat(stream->wrapper, stream, ssb TSRMLS_CC);
834 }
835
836 /* if the stream doesn't directly support stat-ing, return with failure.
837 * We could try and emulate this by casting to a FD and fstat-ing it,
838 * but since the fd might not represent the actual underlying content
839 * this would give bogus results. */
840 if (stream->ops->stat == NULL) {
841 return -1;
842 }
843
844 return (stream->ops->stat)(stream, ssb TSRMLS_CC);
845 }
846
php_stream_locate_eol(php_stream * stream,char * buf,size_t buf_len TSRMLS_DC)847 PHPAPI char *php_stream_locate_eol(php_stream *stream, char *buf, size_t buf_len TSRMLS_DC)
848 {
849 size_t avail;
850 char *cr, *lf, *eol = NULL;
851 char *readptr;
852
853 if (!buf) {
854 readptr = stream->readbuf + stream->readpos;
855 avail = stream->writepos - stream->readpos;
856 } else {
857 readptr = buf;
858 avail = buf_len;
859 }
860
861 /* Look for EOL */
862 if (stream->flags & PHP_STREAM_FLAG_DETECT_EOL) {
863 cr = memchr(readptr, '\r', avail);
864 lf = memchr(readptr, '\n', avail);
865
866 if (cr && lf != cr + 1 && !(lf && lf < cr)) {
867 /* mac */
868 stream->flags ^= PHP_STREAM_FLAG_DETECT_EOL;
869 stream->flags |= PHP_STREAM_FLAG_EOL_MAC;
870 eol = cr;
871 } else if ((cr && lf && cr == lf - 1) || (lf)) {
872 /* dos or unix endings */
873 stream->flags ^= PHP_STREAM_FLAG_DETECT_EOL;
874 eol = lf;
875 }
876 } else if (stream->flags & PHP_STREAM_FLAG_EOL_MAC) {
877 eol = memchr(readptr, '\r', avail);
878 } else {
879 /* unix (and dos) line endings */
880 eol = memchr(readptr, '\n', avail);
881 }
882
883 return eol;
884 }
885
886 /* If buf == NULL, the buffer will be allocated automatically and will be of an
887 * appropriate length to hold the line, regardless of the line length, memory
888 * permitting */
_php_stream_get_line(php_stream * stream,char * buf,size_t maxlen,size_t * returned_len TSRMLS_DC)889 PHPAPI char *_php_stream_get_line(php_stream *stream, char *buf, size_t maxlen,
890 size_t *returned_len TSRMLS_DC)
891 {
892 size_t avail = 0;
893 size_t current_buf_size = 0;
894 size_t total_copied = 0;
895 int grow_mode = 0;
896 char *bufstart = buf;
897
898 if (buf == NULL) {
899 grow_mode = 1;
900 } else if (maxlen == 0) {
901 return NULL;
902 }
903
904 /*
905 * If the underlying stream operations block when no new data is readable,
906 * we need to take extra precautions.
907 *
908 * If there is buffered data available, we check for a EOL. If it exists,
909 * we pass the data immediately back to the caller. This saves a call
910 * to the read implementation and will not block where blocking
911 * is not necessary at all.
912 *
913 * If the stream buffer contains more data than the caller requested,
914 * we can also avoid that costly step and simply return that data.
915 */
916
917 for (;;) {
918 avail = stream->writepos - stream->readpos;
919
920 if (avail > 0) {
921 size_t cpysz = 0;
922 char *readptr;
923 char *eol;
924 int done = 0;
925
926 readptr = stream->readbuf + stream->readpos;
927 eol = php_stream_locate_eol(stream, NULL, 0 TSRMLS_CC);
928
929 if (eol) {
930 cpysz = eol - readptr + 1;
931 done = 1;
932 } else {
933 cpysz = avail;
934 }
935
936 if (grow_mode) {
937 /* allow room for a NUL. If this realloc is really a realloc
938 * (ie: second time around), we get an extra byte. In most
939 * cases, with the default chunk size of 8K, we will only
940 * incur that overhead once. When people have lines longer
941 * than 8K, we waste 1 byte per additional 8K or so.
942 * That seems acceptable to me, to avoid making this code
943 * hard to follow */
944 bufstart = erealloc(bufstart, current_buf_size + cpysz + 1);
945 current_buf_size += cpysz + 1;
946 buf = bufstart + total_copied;
947 } else {
948 if (cpysz >= maxlen - 1) {
949 cpysz = maxlen - 1;
950 done = 1;
951 }
952 }
953
954 memcpy(buf, readptr, cpysz);
955
956 stream->position += cpysz;
957 stream->readpos += cpysz;
958 buf += cpysz;
959 maxlen -= cpysz;
960 total_copied += cpysz;
961
962 if (done) {
963 break;
964 }
965 } else if (stream->eof) {
966 break;
967 } else {
968 /* XXX: Should be fine to always read chunk_size */
969 size_t toread;
970
971 if (grow_mode) {
972 toread = stream->chunk_size;
973 } else {
974 toread = maxlen - 1;
975 if (toread > stream->chunk_size) {
976 toread = stream->chunk_size;
977 }
978 }
979
980 php_stream_fill_read_buffer(stream, toread);
981
982 if (stream->writepos - stream->readpos == 0) {
983 break;
984 }
985 }
986 }
987
988 if (total_copied == 0) {
989 if (grow_mode) {
990 assert(bufstart == NULL);
991 }
992 return NULL;
993 }
994
995 buf[0] = '\0';
996 if (returned_len) {
997 *returned_len = total_copied;
998 }
999
1000 return bufstart;
1001 }
1002
1003 #define STREAM_BUFFERED_AMOUNT(stream) \
1004 ((size_t)(((stream)->writepos) - (stream)->readpos))
1005
_php_stream_search_delim(php_stream * stream,size_t maxlen,size_t skiplen,char * delim,size_t delim_len TSRMLS_DC)1006 static char *_php_stream_search_delim(php_stream *stream,
1007 size_t maxlen,
1008 size_t skiplen,
1009 char *delim, /* non-empty! */
1010 size_t delim_len TSRMLS_DC)
1011 {
1012 size_t seek_len;
1013
1014 /* set the maximum number of bytes we're allowed to read from buffer */
1015 seek_len = MIN(STREAM_BUFFERED_AMOUNT(stream), maxlen);
1016 if (seek_len <= skiplen) {
1017 return NULL;
1018 }
1019
1020 if (delim_len == 1) {
1021 return memchr(&stream->readbuf[stream->readpos + skiplen],
1022 delim[0], seek_len - skiplen);
1023 } else {
1024 return php_memnstr((char*)&stream->readbuf[stream->readpos + skiplen],
1025 delim, delim_len,
1026 (char*)&stream->readbuf[stream->readpos + seek_len]);
1027 }
1028 }
1029
php_stream_get_record(php_stream * stream,size_t maxlen,size_t * returned_len,char * delim,size_t delim_len TSRMLS_DC)1030 PHPAPI char *php_stream_get_record(php_stream *stream, size_t maxlen, size_t *returned_len, char *delim, size_t delim_len TSRMLS_DC)
1031 {
1032 char *ret_buf, /* returned buffer */
1033 *found_delim = NULL;
1034 size_t buffered_len,
1035 tent_ret_len; /* tentative returned length */
1036 int has_delim = delim_len > 0;
1037
1038 if (maxlen == 0) {
1039 return NULL;
1040 }
1041
1042 if (has_delim) {
1043 found_delim = _php_stream_search_delim(
1044 stream, maxlen, 0, delim, delim_len TSRMLS_CC);
1045 }
1046
1047 buffered_len = STREAM_BUFFERED_AMOUNT(stream);
1048 /* try to read up to maxlen length bytes while we don't find the delim */
1049 while (!found_delim && buffered_len < maxlen) {
1050 size_t just_read,
1051 to_read_now;
1052
1053 to_read_now = MIN(maxlen - buffered_len, stream->chunk_size);
1054
1055 php_stream_fill_read_buffer(stream, buffered_len + to_read_now);
1056
1057 just_read = STREAM_BUFFERED_AMOUNT(stream) - buffered_len;
1058
1059 /* Assume the stream is temporarily or permanently out of data */
1060 if (just_read == 0) {
1061 break;
1062 }
1063
1064 if (has_delim) {
1065 /* search for delimiter, but skip buffered_len (the number of bytes
1066 * buffered before this loop iteration), as they have already been
1067 * searched for the delimiter.
1068 * The left part of the delimiter may still remain in the buffer,
1069 * so subtract up to <delim_len - 1> from buffered_len, which is
1070 * the ammount of data we skip on this search as an optimization
1071 */
1072 found_delim = _php_stream_search_delim(
1073 stream, maxlen,
1074 buffered_len >= (delim_len - 1)
1075 ? buffered_len - (delim_len - 1)
1076 : 0,
1077 delim, delim_len TSRMLS_CC);
1078 if (found_delim) {
1079 break;
1080 }
1081 }
1082 buffered_len += just_read;
1083 }
1084
1085 if (has_delim && found_delim) {
1086 tent_ret_len = found_delim - (char*)&stream->readbuf[stream->readpos];
1087 } else if (!has_delim && STREAM_BUFFERED_AMOUNT(stream) >= maxlen) {
1088 tent_ret_len = maxlen;
1089 } else {
1090 /* return with error if the delimiter string (if any) was not found, we
1091 * could not completely fill the read buffer with maxlen bytes and we
1092 * don't know we've reached end of file. Added with non-blocking streams
1093 * in mind, where this situation is frequent */
1094 if (STREAM_BUFFERED_AMOUNT(stream) < maxlen && !stream->eof) {
1095 return NULL;
1096 } else if (STREAM_BUFFERED_AMOUNT(stream) == 0 && stream->eof) {
1097 /* refuse to return an empty string just because by accident
1098 * we knew of EOF in a read that returned no data */
1099 return NULL;
1100 } else {
1101 tent_ret_len = MIN(STREAM_BUFFERED_AMOUNT(stream), maxlen);
1102 }
1103 }
1104
1105 ret_buf = emalloc(tent_ret_len + 1);
1106 /* php_stream_read will not call ops->read here because the necessary
1107 * data is guaranteedly buffered */
1108 *returned_len = php_stream_read(stream, ret_buf, tent_ret_len);
1109
1110 if (found_delim) {
1111 stream->readpos += delim_len;
1112 stream->position += delim_len;
1113 }
1114 ret_buf[*returned_len] = '\0';
1115 return ret_buf;
1116 }
1117
1118 /* Writes a buffer directly to a stream, using multiple of the chunk size */
_php_stream_write_buffer(php_stream * stream,const char * buf,size_t count TSRMLS_DC)1119 static size_t _php_stream_write_buffer(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
1120 {
1121 size_t didwrite = 0, towrite, justwrote;
1122
1123 /* if we have a seekable stream we need to ensure that data is written at the
1124 * current stream->position. This means invalidating the read buffer and then
1125 * performing a low-level seek */
1126 if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && stream->readpos != stream->writepos) {
1127 stream->readpos = stream->writepos = 0;
1128
1129 stream->ops->seek(stream, stream->position, SEEK_SET, &stream->position TSRMLS_CC);
1130 }
1131
1132
1133 while (count > 0) {
1134 towrite = count;
1135 if (towrite > stream->chunk_size)
1136 towrite = stream->chunk_size;
1137
1138 justwrote = stream->ops->write(stream, buf, towrite TSRMLS_CC);
1139
1140 /* convert justwrote to an integer, since normally it is unsigned */
1141 if ((int)justwrote > 0) {
1142 buf += justwrote;
1143 count -= justwrote;
1144 didwrite += justwrote;
1145
1146 /* Only screw with the buffer if we can seek, otherwise we lose data
1147 * buffered from fifos and sockets */
1148 if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
1149 stream->position += justwrote;
1150 }
1151 } else {
1152 break;
1153 }
1154 }
1155 return didwrite;
1156
1157 }
1158
1159 /* push some data through the write filter chain.
1160 * buf may be NULL, if flags are set to indicate a flush.
1161 * This may trigger a real write to the stream.
1162 * Returns the number of bytes consumed from buf by the first filter in the chain.
1163 * */
_php_stream_write_filtered(php_stream * stream,const char * buf,size_t count,int flags TSRMLS_DC)1164 static size_t _php_stream_write_filtered(php_stream *stream, const char *buf, size_t count, int flags TSRMLS_DC)
1165 {
1166 size_t consumed = 0;
1167 php_stream_bucket *bucket;
1168 php_stream_bucket_brigade brig_in = { NULL, NULL }, brig_out = { NULL, NULL };
1169 php_stream_bucket_brigade *brig_inp = &brig_in, *brig_outp = &brig_out, *brig_swap;
1170 php_stream_filter_status_t status = PSFS_ERR_FATAL;
1171 php_stream_filter *filter;
1172
1173 if (buf) {
1174 bucket = php_stream_bucket_new(stream, (char *)buf, count, 0, 0 TSRMLS_CC);
1175 php_stream_bucket_append(&brig_in, bucket TSRMLS_CC);
1176 }
1177
1178 for (filter = stream->writefilters.head; filter; filter = filter->next) {
1179 /* for our return value, we are interested in the number of bytes consumed from
1180 * the first filter in the chain */
1181 status = filter->fops->filter(stream, filter, brig_inp, brig_outp,
1182 filter == stream->writefilters.head ? &consumed : NULL, flags TSRMLS_CC);
1183
1184 if (status != PSFS_PASS_ON) {
1185 break;
1186 }
1187 /* brig_out becomes brig_in.
1188 * brig_in will always be empty here, as the filter MUST attach any un-consumed buckets
1189 * to its own brigade */
1190 brig_swap = brig_inp;
1191 brig_inp = brig_outp;
1192 brig_outp = brig_swap;
1193 memset(brig_outp, 0, sizeof(*brig_outp));
1194 }
1195
1196 switch (status) {
1197 case PSFS_PASS_ON:
1198 /* filter chain generated some output; push it through to the
1199 * underlying stream */
1200 while (brig_inp->head) {
1201 bucket = brig_inp->head;
1202 _php_stream_write_buffer(stream, bucket->buf, bucket->buflen TSRMLS_CC);
1203 /* Potential error situation - eg: no space on device. Perhaps we should keep this brigade
1204 * hanging around and try to write it later.
1205 * At the moment, we just drop it on the floor
1206 * */
1207
1208 php_stream_bucket_unlink(bucket TSRMLS_CC);
1209 php_stream_bucket_delref(bucket TSRMLS_CC);
1210 }
1211 break;
1212 case PSFS_FEED_ME:
1213 /* need more data before we can push data through to the stream */
1214 break;
1215
1216 case PSFS_ERR_FATAL:
1217 /* some fatal error. Theoretically, the stream is borked, so all
1218 * further writes should fail. */
1219 break;
1220 }
1221
1222 return consumed;
1223 }
1224
_php_stream_flush(php_stream * stream,int closing TSRMLS_DC)1225 PHPAPI int _php_stream_flush(php_stream *stream, int closing TSRMLS_DC)
1226 {
1227 int ret = 0;
1228
1229 if (stream->writefilters.head) {
1230 _php_stream_write_filtered(stream, NULL, 0, closing ? PSFS_FLAG_FLUSH_CLOSE : PSFS_FLAG_FLUSH_INC TSRMLS_CC);
1231 }
1232
1233 if (stream->ops->flush) {
1234 ret = stream->ops->flush(stream TSRMLS_CC);
1235 }
1236
1237 return ret;
1238 }
1239
_php_stream_write(php_stream * stream,const char * buf,size_t count TSRMLS_DC)1240 PHPAPI size_t _php_stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
1241 {
1242 if (buf == NULL || count == 0 || stream->ops->write == NULL) {
1243 return 0;
1244 }
1245
1246 if (stream->writefilters.head) {
1247 return _php_stream_write_filtered(stream, buf, count, PSFS_FLAG_NORMAL TSRMLS_CC);
1248 } else {
1249 return _php_stream_write_buffer(stream, buf, count TSRMLS_CC);
1250 }
1251 }
1252
_php_stream_printf(php_stream * stream TSRMLS_DC,const char * fmt,...)1253 PHPAPI size_t _php_stream_printf(php_stream *stream TSRMLS_DC, const char *fmt, ...)
1254 {
1255 size_t count;
1256 char *buf;
1257 va_list ap;
1258
1259 va_start(ap, fmt);
1260 count = vspprintf(&buf, 0, fmt, ap);
1261 va_end(ap);
1262
1263 if (!buf) {
1264 return 0; /* error condition */
1265 }
1266
1267 count = php_stream_write(stream, buf, count);
1268 efree(buf);
1269
1270 return count;
1271 }
1272
_php_stream_tell(php_stream * stream TSRMLS_DC)1273 PHPAPI off_t _php_stream_tell(php_stream *stream TSRMLS_DC)
1274 {
1275 return stream->position;
1276 }
1277
_php_stream_seek(php_stream * stream,off_t offset,int whence TSRMLS_DC)1278 PHPAPI int _php_stream_seek(php_stream *stream, off_t offset, int whence TSRMLS_DC)
1279 {
1280 if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
1281 /* flush to commit data written to the fopencookie FILE* */
1282 fflush(stream->stdiocast);
1283 }
1284
1285 /* handle the case where we are in the buffer */
1286 if ((stream->flags & PHP_STREAM_FLAG_NO_BUFFER) == 0) {
1287 switch(whence) {
1288 case SEEK_CUR:
1289 if (offset > 0 && offset <= stream->writepos - stream->readpos) {
1290 stream->readpos += offset; /* if offset = ..., then readpos = writepos */
1291 stream->position += offset;
1292 stream->eof = 0;
1293 return 0;
1294 }
1295 break;
1296 case SEEK_SET:
1297 if (offset > stream->position &&
1298 offset <= stream->position + stream->writepos - stream->readpos) {
1299 stream->readpos += offset - stream->position;
1300 stream->position = offset;
1301 stream->eof = 0;
1302 return 0;
1303 }
1304 break;
1305 }
1306 }
1307
1308
1309 if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
1310 int ret;
1311
1312 if (stream->writefilters.head) {
1313 _php_stream_flush(stream, 0 TSRMLS_CC);
1314 }
1315
1316 switch(whence) {
1317 case SEEK_CUR:
1318 offset = stream->position + offset;
1319 whence = SEEK_SET;
1320 break;
1321 }
1322 ret = stream->ops->seek(stream, offset, whence, &stream->position TSRMLS_CC);
1323
1324 if (((stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) || ret == 0) {
1325 if (ret == 0) {
1326 stream->eof = 0;
1327 }
1328
1329 /* invalidate the buffer contents */
1330 stream->readpos = stream->writepos = 0;
1331
1332 return ret;
1333 }
1334 /* else the stream has decided that it can't support seeking after all;
1335 * fall through to attempt emulation */
1336 }
1337
1338 /* emulate forward moving seeks with reads */
1339 if (whence == SEEK_CUR && offset >= 0) {
1340 char tmp[1024];
1341 size_t didread;
1342 while(offset > 0) {
1343 if ((didread = php_stream_read(stream, tmp, MIN(offset, sizeof(tmp)))) == 0) {
1344 return -1;
1345 }
1346 offset -= didread;
1347 }
1348 stream->eof = 0;
1349 return 0;
1350 }
1351
1352 php_error_docref(NULL TSRMLS_CC, E_WARNING, "stream does not support seeking");
1353
1354 return -1;
1355 }
1356
_php_stream_set_option(php_stream * stream,int option,int value,void * ptrparam TSRMLS_DC)1357 PHPAPI int _php_stream_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
1358 {
1359 int ret = PHP_STREAM_OPTION_RETURN_NOTIMPL;
1360
1361 if (stream->ops->set_option) {
1362 ret = stream->ops->set_option(stream, option, value, ptrparam TSRMLS_CC);
1363 }
1364
1365 if (ret == PHP_STREAM_OPTION_RETURN_NOTIMPL) {
1366 switch(option) {
1367 case PHP_STREAM_OPTION_SET_CHUNK_SIZE:
1368 ret = stream->chunk_size;
1369 stream->chunk_size = value;
1370 return ret;
1371
1372 case PHP_STREAM_OPTION_READ_BUFFER:
1373 /* try to match the buffer mode as best we can */
1374 if (value == PHP_STREAM_BUFFER_NONE) {
1375 stream->flags |= PHP_STREAM_FLAG_NO_BUFFER;
1376 } else if (stream->flags & PHP_STREAM_FLAG_NO_BUFFER) {
1377 stream->flags ^= PHP_STREAM_FLAG_NO_BUFFER;
1378 }
1379 ret = PHP_STREAM_OPTION_RETURN_OK;
1380 break;
1381
1382 default:
1383 ;
1384 }
1385 }
1386
1387 return ret;
1388 }
1389
_php_stream_truncate_set_size(php_stream * stream,size_t newsize TSRMLS_DC)1390 PHPAPI int _php_stream_truncate_set_size(php_stream *stream, size_t newsize TSRMLS_DC)
1391 {
1392 return php_stream_set_option(stream, PHP_STREAM_OPTION_TRUNCATE_API, PHP_STREAM_TRUNCATE_SET_SIZE, &newsize);
1393 }
1394
_php_stream_passthru(php_stream * stream STREAMS_DC TSRMLS_DC)1395 PHPAPI size_t _php_stream_passthru(php_stream * stream STREAMS_DC TSRMLS_DC)
1396 {
1397 size_t bcount = 0;
1398 char buf[8192];
1399 int b;
1400
1401 if (php_stream_mmap_possible(stream)) {
1402 char *p;
1403 size_t mapped;
1404
1405 p = php_stream_mmap_range(stream, php_stream_tell(stream), PHP_STREAM_MMAP_ALL, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped);
1406
1407 if (p) {
1408 do {
1409 /* output functions return int, so pass in int max */
1410 if (0 < (b = PHPWRITE(p, MIN(mapped - bcount, INT_MAX)))) {
1411 bcount += b;
1412 }
1413 } while (b > 0 && mapped > bcount);
1414
1415 php_stream_mmap_unmap_ex(stream, mapped);
1416
1417 return bcount;
1418 }
1419 }
1420
1421 while ((b = php_stream_read(stream, buf, sizeof(buf))) > 0) {
1422 PHPWRITE(buf, b);
1423 bcount += b;
1424 }
1425
1426 return bcount;
1427 }
1428
1429
_php_stream_copy_to_mem(php_stream * src,char ** buf,size_t maxlen,int persistent STREAMS_DC TSRMLS_DC)1430 PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen, int persistent STREAMS_DC TSRMLS_DC)
1431 {
1432 size_t ret = 0;
1433 char *ptr;
1434 size_t len = 0, max_len;
1435 int step = CHUNK_SIZE;
1436 int min_room = CHUNK_SIZE / 4;
1437 php_stream_statbuf ssbuf;
1438
1439 if (maxlen == 0) {
1440 return 0;
1441 }
1442
1443 if (maxlen == PHP_STREAM_COPY_ALL) {
1444 maxlen = 0;
1445 }
1446
1447 if (maxlen > 0) {
1448 ptr = *buf = pemalloc_rel_orig(maxlen + 1, persistent);
1449 while ((len < maxlen) && !php_stream_eof(src)) {
1450 ret = php_stream_read(src, ptr, maxlen - len);
1451 if (!ret) {
1452 break;
1453 }
1454 len += ret;
1455 ptr += ret;
1456 }
1457 if (len) {
1458 *ptr = '\0';
1459 } else {
1460 pefree(*buf, persistent);
1461 *buf = NULL;
1462 }
1463 return len;
1464 }
1465
1466 /* avoid many reallocs by allocating a good sized chunk to begin with, if
1467 * we can. Note that the stream may be filtered, in which case the stat
1468 * result may be inaccurate, as the filter may inflate or deflate the
1469 * number of bytes that we can read. In order to avoid an upsize followed
1470 * by a downsize of the buffer, overestimate by the step size (which is
1471 * 2K). */
1472 if (php_stream_stat(src, &ssbuf) == 0 && ssbuf.sb.st_size > 0) {
1473 max_len = ssbuf.sb.st_size + step;
1474 } else {
1475 max_len = step;
1476 }
1477
1478 ptr = *buf = pemalloc_rel_orig(max_len, persistent);
1479
1480 while((ret = php_stream_read(src, ptr, max_len - len))) {
1481 len += ret;
1482 if (len + min_room >= max_len) {
1483 *buf = perealloc_rel_orig(*buf, max_len + step, persistent);
1484 max_len += step;
1485 ptr = *buf + len;
1486 } else {
1487 ptr += ret;
1488 }
1489 }
1490 if (len) {
1491 *buf = perealloc_rel_orig(*buf, len + 1, persistent);
1492 (*buf)[len] = '\0';
1493 } else {
1494 pefree(*buf, persistent);
1495 *buf = NULL;
1496 }
1497 return len;
1498 }
1499
1500 /* Returns SUCCESS/FAILURE and sets *len to the number of bytes moved */
_php_stream_copy_to_stream_ex(php_stream * src,php_stream * dest,size_t maxlen,size_t * len STREAMS_DC TSRMLS_DC)1501 PHPAPI int _php_stream_copy_to_stream_ex(php_stream *src, php_stream *dest, size_t maxlen, size_t *len STREAMS_DC TSRMLS_DC)
1502 {
1503 char buf[CHUNK_SIZE];
1504 size_t readchunk;
1505 size_t haveread = 0;
1506 size_t didread, didwrite, towrite;
1507 size_t dummy;
1508 php_stream_statbuf ssbuf;
1509
1510 if (!len) {
1511 len = &dummy;
1512 }
1513
1514 if (maxlen == 0) {
1515 *len = 0;
1516 return SUCCESS;
1517 }
1518
1519 if (maxlen == PHP_STREAM_COPY_ALL) {
1520 maxlen = 0;
1521 }
1522
1523 if (php_stream_stat(src, &ssbuf) == 0) {
1524 if (ssbuf.sb.st_size == 0
1525 #ifdef S_ISREG
1526 && S_ISREG(ssbuf.sb.st_mode)
1527 #endif
1528 ) {
1529 *len = 0;
1530 return SUCCESS;
1531 }
1532 }
1533
1534 if (php_stream_mmap_possible(src)) {
1535 char *p;
1536 size_t mapped;
1537
1538 p = php_stream_mmap_range(src, php_stream_tell(src), maxlen, PHP_STREAM_MAP_MODE_SHARED_READONLY, &mapped);
1539
1540 if (p) {
1541 didwrite = php_stream_write(dest, p, mapped);
1542
1543 php_stream_mmap_unmap_ex(src, mapped);
1544
1545 *len = didwrite;
1546
1547 /* we've got at least 1 byte to read
1548 * less than 1 is an error
1549 * AND read bytes match written */
1550 if (mapped > 0 && mapped == didwrite) {
1551 return SUCCESS;
1552 }
1553 return FAILURE;
1554 }
1555 }
1556
1557 while(1) {
1558 readchunk = sizeof(buf);
1559
1560 if (maxlen && (maxlen - haveread) < readchunk) {
1561 readchunk = maxlen - haveread;
1562 }
1563
1564 didread = php_stream_read(src, buf, readchunk);
1565
1566 if (didread) {
1567 /* extra paranoid */
1568 char *writeptr;
1569
1570 towrite = didread;
1571 writeptr = buf;
1572 haveread += didread;
1573
1574 while(towrite) {
1575 didwrite = php_stream_write(dest, writeptr, towrite);
1576 if (didwrite == 0) {
1577 *len = haveread - (didread - towrite);
1578 return FAILURE;
1579 }
1580
1581 towrite -= didwrite;
1582 writeptr += didwrite;
1583 }
1584 } else {
1585 break;
1586 }
1587
1588 if (maxlen - haveread == 0) {
1589 break;
1590 }
1591 }
1592
1593 *len = haveread;
1594
1595 /* we've got at least 1 byte to read.
1596 * less than 1 is an error */
1597
1598 if (haveread > 0 || src->eof) {
1599 return SUCCESS;
1600 }
1601 return FAILURE;
1602 }
1603
1604 /* Returns the number of bytes moved.
1605 * Returns 1 when source len is 0.
1606 * Deprecated in favor of php_stream_copy_to_stream_ex() */
1607 ZEND_ATTRIBUTE_DEPRECATED
_php_stream_copy_to_stream(php_stream * src,php_stream * dest,size_t maxlen STREAMS_DC TSRMLS_DC)1608 PHPAPI size_t _php_stream_copy_to_stream(php_stream *src, php_stream *dest, size_t maxlen STREAMS_DC TSRMLS_DC)
1609 {
1610 size_t len;
1611 int ret = _php_stream_copy_to_stream_ex(src, dest, maxlen, &len STREAMS_REL_CC TSRMLS_CC);
1612 if (ret == SUCCESS && len == 0 && maxlen != 0) {
1613 return 1;
1614 }
1615 return len;
1616 }
1617 /* }}} */
1618
1619 /* {{{ wrapper init and registration */
1620
stream_resource_regular_dtor(zend_rsrc_list_entry * rsrc TSRMLS_DC)1621 static void stream_resource_regular_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
1622 {
1623 php_stream *stream = (php_stream*)rsrc->ptr;
1624 /* set the return value for pclose */
1625 FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
1626 }
1627
stream_resource_persistent_dtor(zend_rsrc_list_entry * rsrc TSRMLS_DC)1628 static void stream_resource_persistent_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
1629 {
1630 php_stream *stream = (php_stream*)rsrc->ptr;
1631 FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
1632 }
1633
php_shutdown_stream_hashes(TSRMLS_D)1634 void php_shutdown_stream_hashes(TSRMLS_D)
1635 {
1636 if (FG(stream_wrappers)) {
1637 zend_hash_destroy(FG(stream_wrappers));
1638 efree(FG(stream_wrappers));
1639 FG(stream_wrappers) = NULL;
1640 }
1641
1642 if (FG(stream_filters)) {
1643 zend_hash_destroy(FG(stream_filters));
1644 efree(FG(stream_filters));
1645 FG(stream_filters) = NULL;
1646 }
1647
1648 if (FG(wrapper_errors)) {
1649 zend_hash_destroy(FG(wrapper_errors));
1650 efree(FG(wrapper_errors));
1651 FG(wrapper_errors) = NULL;
1652 }
1653 }
1654
php_init_stream_wrappers(int module_number TSRMLS_DC)1655 int php_init_stream_wrappers(int module_number TSRMLS_DC)
1656 {
1657 le_stream = zend_register_list_destructors_ex(stream_resource_regular_dtor, NULL, "stream", module_number);
1658 le_pstream = zend_register_list_destructors_ex(NULL, stream_resource_persistent_dtor, "persistent stream", module_number);
1659
1660 /* Filters are cleaned up by the streams they're attached to */
1661 le_stream_filter = zend_register_list_destructors_ex(NULL, NULL, "stream filter", module_number);
1662
1663 return (
1664 zend_hash_init(&url_stream_wrappers_hash, 0, NULL, NULL, 1) == SUCCESS
1665 &&
1666 zend_hash_init(php_get_stream_filters_hash_global(), 0, NULL, NULL, 1) == SUCCESS
1667 &&
1668 zend_hash_init(php_stream_xport_get_hash(), 0, NULL, NULL, 1) == SUCCESS
1669 &&
1670 php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
1671 &&
1672 php_stream_xport_register("udp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
1673 #if defined(AF_UNIX) && !(defined(PHP_WIN32) || defined(__riscos__) || defined(NETWARE))
1674 &&
1675 php_stream_xport_register("unix", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
1676 &&
1677 php_stream_xport_register("udg", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
1678 #endif
1679 ) ? SUCCESS : FAILURE;
1680 }
1681
php_shutdown_stream_wrappers(int module_number TSRMLS_DC)1682 int php_shutdown_stream_wrappers(int module_number TSRMLS_DC)
1683 {
1684 zend_hash_destroy(&url_stream_wrappers_hash);
1685 zend_hash_destroy(php_get_stream_filters_hash_global());
1686 zend_hash_destroy(php_stream_xport_get_hash());
1687 return SUCCESS;
1688 }
1689
1690 /* Validate protocol scheme names during registration
1691 * Must conform to /^[a-zA-Z0-9+.-]+$/
1692 */
php_stream_wrapper_scheme_validate(char * protocol,int protocol_len)1693 static inline int php_stream_wrapper_scheme_validate(char *protocol, int protocol_len)
1694 {
1695 int i;
1696
1697 for(i = 0; i < protocol_len; i++) {
1698 if (!isalnum((int)protocol[i]) &&
1699 protocol[i] != '+' &&
1700 protocol[i] != '-' &&
1701 protocol[i] != '.') {
1702 return FAILURE;
1703 }
1704 }
1705
1706 return SUCCESS;
1707 }
1708
1709 /* API for registering GLOBAL wrappers */
php_register_url_stream_wrapper(char * protocol,php_stream_wrapper * wrapper TSRMLS_DC)1710 PHPAPI int php_register_url_stream_wrapper(char *protocol, php_stream_wrapper *wrapper TSRMLS_DC)
1711 {
1712 int protocol_len = strlen(protocol);
1713
1714 if (php_stream_wrapper_scheme_validate(protocol, protocol_len) == FAILURE) {
1715 return FAILURE;
1716 }
1717
1718 return zend_hash_add(&url_stream_wrappers_hash, protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
1719 }
1720
php_unregister_url_stream_wrapper(char * protocol TSRMLS_DC)1721 PHPAPI int php_unregister_url_stream_wrapper(char *protocol TSRMLS_DC)
1722 {
1723 return zend_hash_del(&url_stream_wrappers_hash, protocol, strlen(protocol) + 1);
1724 }
1725
clone_wrapper_hash(TSRMLS_D)1726 static void clone_wrapper_hash(TSRMLS_D)
1727 {
1728 php_stream_wrapper *tmp;
1729
1730 ALLOC_HASHTABLE(FG(stream_wrappers));
1731 zend_hash_init(FG(stream_wrappers), zend_hash_num_elements(&url_stream_wrappers_hash), NULL, NULL, 1);
1732 zend_hash_copy(FG(stream_wrappers), &url_stream_wrappers_hash, NULL, &tmp, sizeof(tmp));
1733 }
1734
1735 /* API for registering VOLATILE wrappers */
php_register_url_stream_wrapper_volatile(char * protocol,php_stream_wrapper * wrapper TSRMLS_DC)1736 PHPAPI int php_register_url_stream_wrapper_volatile(char *protocol, php_stream_wrapper *wrapper TSRMLS_DC)
1737 {
1738 int protocol_len = strlen(protocol);
1739
1740 if (php_stream_wrapper_scheme_validate(protocol, protocol_len) == FAILURE) {
1741 return FAILURE;
1742 }
1743
1744 if (!FG(stream_wrappers)) {
1745 clone_wrapper_hash(TSRMLS_C);
1746 }
1747
1748 return zend_hash_add(FG(stream_wrappers), protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
1749 }
1750
php_unregister_url_stream_wrapper_volatile(char * protocol TSRMLS_DC)1751 PHPAPI int php_unregister_url_stream_wrapper_volatile(char *protocol TSRMLS_DC)
1752 {
1753 if (!FG(stream_wrappers)) {
1754 clone_wrapper_hash(TSRMLS_C);
1755 }
1756
1757 return zend_hash_del(FG(stream_wrappers), protocol, strlen(protocol) + 1);
1758 }
1759 /* }}} */
1760
1761 /* {{{ php_stream_locate_url_wrapper */
php_stream_locate_url_wrapper(const char * path,char ** path_for_open,int options TSRMLS_DC)1762 PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, char **path_for_open, int options TSRMLS_DC)
1763 {
1764 HashTable *wrapper_hash = (FG(stream_wrappers) ? FG(stream_wrappers) : &url_stream_wrappers_hash);
1765 php_stream_wrapper **wrapperpp = NULL;
1766 const char *p, *protocol = NULL;
1767 int n = 0;
1768
1769 if (path_for_open) {
1770 *path_for_open = (char*)path;
1771 }
1772
1773 if (options & IGNORE_URL) {
1774 return (options & STREAM_LOCATE_WRAPPERS_ONLY) ? NULL : &php_plain_files_wrapper;
1775 }
1776
1777 for (p = path; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; p++) {
1778 n++;
1779 }
1780
1781 if ((*p == ':') && (n > 1) && (!strncmp("//", p+1, 2) || (n == 4 && !memcmp("data:", path, 5)))) {
1782 protocol = path;
1783 } else if (n == 5 && strncasecmp(path, "zlib:", 5) == 0) {
1784 /* BC with older php scripts and zlib wrapper */
1785 protocol = "compress.zlib";
1786 n = 13;
1787 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Use of \"zlib:\" wrapper is deprecated; please use \"compress.zlib://\" instead");
1788 }
1789
1790 if (protocol) {
1791 char *tmp = estrndup(protocol, n);
1792 if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
1793 php_strtolower(tmp, n);
1794 if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
1795 char wrapper_name[32];
1796
1797 if (n >= sizeof(wrapper_name)) {
1798 n = sizeof(wrapper_name) - 1;
1799 }
1800 PHP_STRLCPY(wrapper_name, protocol, sizeof(wrapper_name), n);
1801
1802 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);
1803
1804 wrapperpp = NULL;
1805 protocol = NULL;
1806 }
1807 }
1808 efree(tmp);
1809 }
1810 /* TODO: curl based streams probably support file:// properly */
1811 if (!protocol || !strncasecmp(protocol, "file", n)) {
1812 /* fall back on regular file access */
1813 php_stream_wrapper *plain_files_wrapper = &php_plain_files_wrapper;
1814
1815 if (protocol) {
1816 int localhost = 0;
1817
1818 if (!strncasecmp(path, "file://localhost/", 17)) {
1819 localhost = 1;
1820 }
1821
1822 #ifdef PHP_WIN32
1823 if (localhost == 0 && path[n+3] != '\0' && path[n+3] != '/' && path[n+4] != ':') {
1824 #else
1825 if (localhost == 0 && path[n+3] != '\0' && path[n+3] != '/') {
1826 #endif
1827 if (options & REPORT_ERRORS) {
1828 php_error_docref(NULL TSRMLS_CC, E_WARNING, "remote host file access not supported, %s", path);
1829 }
1830 return NULL;
1831 }
1832
1833 if (path_for_open) {
1834 /* skip past protocol and :/, but handle windows correctly */
1835 *path_for_open = (char*)path + n + 1;
1836 if (localhost == 1) {
1837 (*path_for_open) += 11;
1838 }
1839 while (*(++*path_for_open)=='/');
1840 #ifdef PHP_WIN32
1841 if (*(*path_for_open + 1) != ':')
1842 #endif
1843 (*path_for_open)--;
1844 }
1845 }
1846
1847 if (options & STREAM_LOCATE_WRAPPERS_ONLY) {
1848 return NULL;
1849 }
1850
1851 if (FG(stream_wrappers)) {
1852 /* The file:// wrapper may have been disabled/overridden */
1853
1854 if (wrapperpp) {
1855 /* It was found so go ahead and provide it */
1856 return *wrapperpp;
1857 }
1858
1859 /* Check again, the original check might have not known the protocol name */
1860 if (zend_hash_find(wrapper_hash, "file", sizeof("file"), (void**)&wrapperpp) == SUCCESS) {
1861 return *wrapperpp;
1862 }
1863
1864 if (options & REPORT_ERRORS) {
1865 php_error_docref(NULL TSRMLS_CC, E_WARNING, "file:// wrapper is disabled in the server configuration");
1866 }
1867 return NULL;
1868 }
1869
1870 return plain_files_wrapper;
1871 }
1872
1873 if (wrapperpp && (*wrapperpp)->is_url &&
1874 (options & STREAM_DISABLE_URL_PROTECTION) == 0 &&
1875 (!PG(allow_url_fopen) ||
1876 (((options & STREAM_OPEN_FOR_INCLUDE) ||
1877 PG(in_user_include)) && !PG(allow_url_include)))) {
1878 if (options & REPORT_ERRORS) {
1879 /* protocol[n] probably isn't '\0' */
1880 char *protocol_dup = estrndup(protocol, n);
1881 if (!PG(allow_url_fopen)) {
1882 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// wrapper is disabled in the server configuration by allow_url_fopen=0", protocol_dup);
1883 } else {
1884 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// wrapper is disabled in the server configuration by allow_url_include=0", protocol_dup);
1885 }
1886 efree(protocol_dup);
1887 }
1888 return NULL;
1889 }
1890
1891 return *wrapperpp;
1892 }
1893 /* }}} */
1894
1895 /* {{{ _php_stream_mkdir
1896 */
1897 PHPAPI int _php_stream_mkdir(char *path, int mode, int options, php_stream_context *context TSRMLS_DC)
1898 {
1899 php_stream_wrapper *wrapper = NULL;
1900
1901 wrapper = php_stream_locate_url_wrapper(path, NULL, 0 TSRMLS_CC);
1902 if (!wrapper || !wrapper->wops || !wrapper->wops->stream_mkdir) {
1903 return 0;
1904 }
1905
1906 return wrapper->wops->stream_mkdir(wrapper, path, mode, options, context TSRMLS_CC);
1907 }
1908 /* }}} */
1909
1910 /* {{{ _php_stream_rmdir
1911 */
1912 PHPAPI int _php_stream_rmdir(char *path, int options, php_stream_context *context TSRMLS_DC)
1913 {
1914 php_stream_wrapper *wrapper = NULL;
1915
1916 wrapper = php_stream_locate_url_wrapper(path, NULL, 0 TSRMLS_CC);
1917 if (!wrapper || !wrapper->wops || !wrapper->wops->stream_rmdir) {
1918 return 0;
1919 }
1920
1921 return wrapper->wops->stream_rmdir(wrapper, path, options, context TSRMLS_CC);
1922 }
1923 /* }}} */
1924
1925 /* {{{ _php_stream_stat_path */
1926 PHPAPI int _php_stream_stat_path(char *path, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
1927 {
1928 php_stream_wrapper *wrapper = NULL;
1929 char *path_to_open = path;
1930 int ret;
1931
1932 if (!(flags & PHP_STREAM_URL_STAT_NOCACHE)) {
1933 /* Try to hit the cache first */
1934 if (flags & PHP_STREAM_URL_STAT_LINK) {
1935 if (BG(CurrentLStatFile) && strcmp(path, BG(CurrentLStatFile)) == 0) {
1936 memcpy(ssb, &BG(lssb), sizeof(php_stream_statbuf));
1937 return 0;
1938 }
1939 } else {
1940 if (BG(CurrentStatFile) && strcmp(path, BG(CurrentStatFile)) == 0) {
1941 memcpy(ssb, &BG(ssb), sizeof(php_stream_statbuf));
1942 return 0;
1943 }
1944 }
1945 }
1946
1947 wrapper = php_stream_locate_url_wrapper(path, &path_to_open, 0 TSRMLS_CC);
1948 if (wrapper && wrapper->wops->url_stat) {
1949 ret = wrapper->wops->url_stat(wrapper, path_to_open, flags, ssb, context TSRMLS_CC);
1950 if (ret == 0) {
1951 if (!(flags & PHP_STREAM_URL_STAT_NOCACHE)) {
1952 /* Drop into cache */
1953 if (flags & PHP_STREAM_URL_STAT_LINK) {
1954 if (BG(CurrentLStatFile)) {
1955 efree(BG(CurrentLStatFile));
1956 }
1957 BG(CurrentLStatFile) = estrdup(path);
1958 memcpy(&BG(lssb), ssb, sizeof(php_stream_statbuf));
1959 } else {
1960 if (BG(CurrentStatFile)) {
1961 efree(BG(CurrentStatFile));
1962 }
1963 BG(CurrentStatFile) = estrdup(path);
1964 memcpy(&BG(ssb), ssb, sizeof(php_stream_statbuf));
1965 }
1966 }
1967 }
1968 return ret;
1969 }
1970 return -1;
1971 }
1972 /* }}} */
1973
1974 /* {{{ php_stream_opendir */
1975 PHPAPI php_stream *_php_stream_opendir(char *path, int options,
1976 php_stream_context *context STREAMS_DC TSRMLS_DC)
1977 {
1978 php_stream *stream = NULL;
1979 php_stream_wrapper *wrapper = NULL;
1980 char *path_to_open;
1981
1982 if (!path || !*path) {
1983 return NULL;
1984 }
1985
1986 path_to_open = path;
1987
1988 wrapper = php_stream_locate_url_wrapper(path, &path_to_open, options TSRMLS_CC);
1989
1990 if (wrapper && wrapper->wops->dir_opener) {
1991 stream = wrapper->wops->dir_opener(wrapper,
1992 path_to_open, "r", options ^ REPORT_ERRORS, NULL,
1993 context STREAMS_REL_CC TSRMLS_CC);
1994
1995 if (stream) {
1996 stream->wrapper = wrapper;
1997 stream->flags |= PHP_STREAM_FLAG_NO_BUFFER | PHP_STREAM_FLAG_IS_DIR;
1998 }
1999 } else if (wrapper) {
2000 php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC, "not implemented");
2001 }
2002 if (stream == NULL && (options & REPORT_ERRORS)) {
2003 php_stream_display_wrapper_errors(wrapper, path, "failed to open dir" TSRMLS_CC);
2004 }
2005 php_stream_tidy_wrapper_error_log(wrapper TSRMLS_CC);
2006
2007 return stream;
2008 }
2009 /* }}} */
2010
2011 /* {{{ _php_stream_readdir */
2012 PHPAPI php_stream_dirent *_php_stream_readdir(php_stream *dirstream, php_stream_dirent *ent TSRMLS_DC)
2013 {
2014
2015 if (sizeof(php_stream_dirent) == php_stream_read(dirstream, (char*)ent, sizeof(php_stream_dirent))) {
2016 return ent;
2017 }
2018
2019 return NULL;
2020 }
2021 /* }}} */
2022
2023 /* {{{ php_stream_open_wrapper_ex */
2024 PHPAPI php_stream *_php_stream_open_wrapper_ex(char *path, char *mode, int options,
2025 char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
2026 {
2027 php_stream *stream = NULL;
2028 php_stream_wrapper *wrapper = NULL;
2029 char *path_to_open;
2030 int persistent = options & STREAM_OPEN_PERSISTENT;
2031 char *resolved_path = NULL;
2032 char *copy_of_path = NULL;
2033
2034 if (opened_path) {
2035 *opened_path = NULL;
2036 }
2037
2038 if (!path || !*path) {
2039 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filename cannot be empty");
2040 return NULL;
2041 }
2042
2043 if (options & USE_PATH) {
2044 resolved_path = zend_resolve_path(path, strlen(path) TSRMLS_CC);
2045 if (resolved_path) {
2046 path = resolved_path;
2047 /* we've found this file, don't re-check include_path or run realpath */
2048 options |= STREAM_ASSUME_REALPATH;
2049 options &= ~USE_PATH;
2050 }
2051 }
2052
2053 path_to_open = path;
2054
2055 wrapper = php_stream_locate_url_wrapper(path, &path_to_open, options TSRMLS_CC);
2056 if (options & STREAM_USE_URL && (!wrapper || !wrapper->is_url)) {
2057 php_error_docref(NULL TSRMLS_CC, E_WARNING, "This function may only be used against URLs");
2058 if (resolved_path) {
2059 efree(resolved_path);
2060 }
2061 return NULL;
2062 }
2063
2064 if (wrapper) {
2065 if (!wrapper->wops->stream_opener) {
2066 php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC,
2067 "wrapper does not support stream open");
2068 } else {
2069 stream = wrapper->wops->stream_opener(wrapper,
2070 path_to_open, mode, options ^ REPORT_ERRORS,
2071 opened_path, context STREAMS_REL_CC TSRMLS_CC);
2072 }
2073
2074 /* if the caller asked for a persistent stream but the wrapper did not
2075 * return one, force an error here */
2076 if (stream && (options & STREAM_OPEN_PERSISTENT) && !stream->is_persistent) {
2077 php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS TSRMLS_CC,
2078 "wrapper does not support persistent streams");
2079 php_stream_close(stream);
2080 stream = NULL;
2081 }
2082
2083 if (stream) {
2084 stream->wrapper = wrapper;
2085 }
2086 }
2087
2088 if (stream) {
2089 if (opened_path && !*opened_path && resolved_path) {
2090 *opened_path = resolved_path;
2091 resolved_path = NULL;
2092 }
2093 if (stream->orig_path) {
2094 pefree(stream->orig_path, persistent);
2095 }
2096 copy_of_path = pestrdup(path, persistent);
2097 stream->orig_path = copy_of_path;
2098 #if ZEND_DEBUG
2099 stream->open_filename = __zend_orig_filename ? __zend_orig_filename : __zend_filename;
2100 stream->open_lineno = __zend_orig_lineno ? __zend_orig_lineno : __zend_lineno;
2101 #endif
2102 }
2103
2104 if (stream != NULL && (options & STREAM_MUST_SEEK)) {
2105 php_stream *newstream;
2106
2107 switch(php_stream_make_seekable_rel(stream, &newstream,
2108 (options & STREAM_WILL_CAST)
2109 ? PHP_STREAM_PREFER_STDIO : PHP_STREAM_NO_PREFERENCE)) {
2110 case PHP_STREAM_UNCHANGED:
2111 if (resolved_path) {
2112 efree(resolved_path);
2113 }
2114 return stream;
2115 case PHP_STREAM_RELEASED:
2116 if (newstream->orig_path) {
2117 pefree(newstream->orig_path, persistent);
2118 }
2119 newstream->orig_path = pestrdup(path, persistent);
2120 if (resolved_path) {
2121 efree(resolved_path);
2122 }
2123 return newstream;
2124 default:
2125 php_stream_close(stream);
2126 stream = NULL;
2127 if (options & REPORT_ERRORS) {
2128 char *tmp = estrdup(path);
2129 php_strip_url_passwd(tmp);
2130 php_error_docref1(NULL TSRMLS_CC, tmp, E_WARNING, "could not make seekable - %s",
2131 tmp);
2132 efree(tmp);
2133
2134 options ^= REPORT_ERRORS;
2135 }
2136 }
2137 }
2138
2139 if (stream && stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && strchr(mode, 'a') && stream->position == 0) {
2140 off_t newpos = 0;
2141
2142 /* if opened for append, we need to revise our idea of the initial file position */
2143 if (0 == stream->ops->seek(stream, 0, SEEK_CUR, &newpos TSRMLS_CC)) {
2144 stream->position = newpos;
2145 }
2146 }
2147
2148 if (stream == NULL && (options & REPORT_ERRORS)) {
2149 php_stream_display_wrapper_errors(wrapper, path, "failed to open stream" TSRMLS_CC);
2150 if (opened_path && *opened_path) {
2151 efree(*opened_path);
2152 *opened_path = NULL;
2153 }
2154 }
2155 php_stream_tidy_wrapper_error_log(wrapper TSRMLS_CC);
2156 #if ZEND_DEBUG
2157 if (stream == NULL && copy_of_path != NULL) {
2158 pefree(copy_of_path, persistent);
2159 }
2160 #endif
2161 if (resolved_path) {
2162 efree(resolved_path);
2163 }
2164 return stream;
2165 }
2166 /* }}} */
2167
2168 /* {{{ context API */
2169 PHPAPI php_stream_context *php_stream_context_set(php_stream *stream, php_stream_context *context)
2170 {
2171 php_stream_context *oldcontext = stream->context;
2172 TSRMLS_FETCH();
2173
2174 stream->context = context;
2175
2176 if (context) {
2177 zend_list_addref(context->rsrc_id);
2178 }
2179 if (oldcontext) {
2180 zend_list_delete(oldcontext->rsrc_id);
2181 }
2182
2183 return oldcontext;
2184 }
2185
2186 PHPAPI void php_stream_notification_notify(php_stream_context *context, int notifycode, int severity,
2187 char *xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void * ptr TSRMLS_DC)
2188 {
2189 if (context && context->notifier)
2190 context->notifier->func(context, notifycode, severity, xmsg, xcode, bytes_sofar, bytes_max, ptr TSRMLS_CC);
2191 }
2192
2193 PHPAPI void php_stream_context_free(php_stream_context *context)
2194 {
2195 if (context->options) {
2196 zval_ptr_dtor(&context->options);
2197 context->options = NULL;
2198 }
2199 if (context->notifier) {
2200 php_stream_notification_free(context->notifier);
2201 context->notifier = NULL;
2202 }
2203 if (context->links) {
2204 zval_ptr_dtor(&context->links);
2205 context->links = NULL;
2206 }
2207 efree(context);
2208 }
2209
2210 PHPAPI php_stream_context *php_stream_context_alloc(TSRMLS_D)
2211 {
2212 php_stream_context *context;
2213
2214 context = ecalloc(1, sizeof(php_stream_context));
2215 context->notifier = NULL;
2216 MAKE_STD_ZVAL(context->options);
2217 array_init(context->options);
2218
2219 context->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, context, php_le_stream_context(TSRMLS_C));
2220 return context;
2221 }
2222
2223 PHPAPI php_stream_notifier *php_stream_notification_alloc(void)
2224 {
2225 return ecalloc(1, sizeof(php_stream_notifier));
2226 }
2227
2228 PHPAPI void php_stream_notification_free(php_stream_notifier *notifier)
2229 {
2230 if (notifier->dtor) {
2231 notifier->dtor(notifier);
2232 }
2233 efree(notifier);
2234 }
2235
2236 PHPAPI int php_stream_context_get_option(php_stream_context *context,
2237 const char *wrappername, const char *optionname, zval ***optionvalue)
2238 {
2239 zval **wrapperhash;
2240
2241 if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
2242 return FAILURE;
2243 }
2244 return zend_hash_find(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)optionvalue);
2245 }
2246
2247 PHPAPI int php_stream_context_set_option(php_stream_context *context,
2248 const char *wrappername, const char *optionname, zval *optionvalue)
2249 {
2250 zval **wrapperhash;
2251 zval *category, *copied_val;
2252
2253 ALLOC_INIT_ZVAL(copied_val);
2254 *copied_val = *optionvalue;
2255 zval_copy_ctor(copied_val);
2256 INIT_PZVAL(copied_val);
2257
2258 if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
2259 MAKE_STD_ZVAL(category);
2260 array_init(category);
2261 if (FAILURE == zend_hash_update(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&category, sizeof(zval *), NULL)) {
2262 return FAILURE;
2263 }
2264
2265 wrapperhash = &category;
2266 }
2267 return zend_hash_update(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)&copied_val, sizeof(zval *), NULL);
2268 }
2269
2270 PHPAPI int php_stream_context_get_link(php_stream_context *context,
2271 const char *hostent, php_stream **stream)
2272 {
2273 php_stream **pstream;
2274
2275 if (!stream || !hostent || !context || !(context->links)) {
2276 return FAILURE;
2277 }
2278 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&pstream)) {
2279 *stream = *pstream;
2280 return SUCCESS;
2281 }
2282 return FAILURE;
2283 }
2284
2285 PHPAPI int php_stream_context_set_link(php_stream_context *context,
2286 const char *hostent, php_stream *stream)
2287 {
2288 if (!context) {
2289 return FAILURE;
2290 }
2291 if (!context->links) {
2292 ALLOC_INIT_ZVAL(context->links);
2293 array_init(context->links);
2294 }
2295 if (!stream) {
2296 /* Delete any entry for <hostent> */
2297 return zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1);
2298 }
2299 return zend_hash_update(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&stream, sizeof(php_stream *), NULL);
2300 }
2301
2302 PHPAPI int php_stream_context_del_link(php_stream_context *context,
2303 php_stream *stream)
2304 {
2305 php_stream **pstream;
2306 char *hostent;
2307 int ret = SUCCESS;
2308
2309 if (!context || !context->links || !stream) {
2310 return FAILURE;
2311 }
2312
2313 for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(context->links));
2314 SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(context->links), (void**)&pstream);
2315 zend_hash_move_forward(Z_ARRVAL_P(context->links))) {
2316 if (*pstream == stream) {
2317 if (SUCCESS == zend_hash_get_current_key(Z_ARRVAL_P(context->links), &hostent, NULL, 0)) {
2318 if (FAILURE == zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1)) {
2319 ret = FAILURE;
2320 }
2321 } else {
2322 ret = FAILURE;
2323 }
2324 }
2325 }
2326
2327 return ret;
2328 }
2329 /* }}} */
2330
2331 /* {{{ php_stream_dirent_alphasort
2332 */
2333 PHPAPI int php_stream_dirent_alphasort(const char **a, const char **b)
2334 {
2335 return strcoll(*a, *b);
2336 }
2337 /* }}} */
2338
2339 /* {{{ php_stream_dirent_alphasortr
2340 */
2341 PHPAPI int php_stream_dirent_alphasortr(const char **a, const char **b)
2342 {
2343 return strcoll(*b, *a);
2344 }
2345 /* }}} */
2346
2347 /* {{{ php_stream_scandir
2348 */
2349 PHPAPI int _php_stream_scandir(char *dirname, char **namelist[], int flags, php_stream_context *context,
2350 int (*compare) (const char **a, const char **b) TSRMLS_DC)
2351 {
2352 php_stream *stream;
2353 php_stream_dirent sdp;
2354 char **vector = NULL;
2355 unsigned int vector_size = 0;
2356 unsigned int nfiles = 0;
2357
2358 if (!namelist) {
2359 return FAILURE;
2360 }
2361
2362 stream = php_stream_opendir(dirname, REPORT_ERRORS, context);
2363 if (!stream) {
2364 return FAILURE;
2365 }
2366
2367 while (php_stream_readdir(stream, &sdp)) {
2368 if (nfiles == vector_size) {
2369 if (vector_size == 0) {
2370 vector_size = 10;
2371 } else {
2372 if(vector_size*2 < vector_size) {
2373 /* overflow */
2374 php_stream_closedir(stream);
2375 efree(vector);
2376 return FAILURE;
2377 }
2378 vector_size *= 2;
2379 }
2380 vector = (char **) safe_erealloc(vector, vector_size, sizeof(char *), 0);
2381 }
2382
2383 vector[nfiles] = estrdup(sdp.d_name);
2384
2385 nfiles++;
2386 if(vector_size < 10 || nfiles == 0) {
2387 /* overflow */
2388 php_stream_closedir(stream);
2389 efree(vector);
2390 return FAILURE;
2391 }
2392 }
2393 php_stream_closedir(stream);
2394
2395 *namelist = vector;
2396
2397 if (nfiles > 0 && compare) {
2398 qsort(*namelist, nfiles, sizeof(char *), (int(*)(const void *, const void *))compare);
2399 }
2400 return nfiles;
2401 }
2402 /* }}} */
2403
2404 /*
2405 * Local variables:
2406 * tab-width: 4
2407 * c-basic-offset: 4
2408 * End:
2409 * vim600: noet sw=4 ts=4 fdm=marker
2410 * vim<600: noet sw=4 ts=4
2411 */
2412
