Annotation of embedaddon/php/main/streams/userspace.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Wez Furlong <wez@thebrainroom.com> |
16: | Sara Golemon <pollita@php.net> |
17: +----------------------------------------------------------------------+
18: */
19:
20: /* $Id: userspace.c 321634 2012-01-01 13:15:04Z felipe $ */
21:
22: #include "php.h"
23: #include "php_globals.h"
24: #include "ext/standard/file.h"
25: #include "ext/standard/flock_compat.h"
26: #ifdef HAVE_SYS_FILE_H
27: #include <sys/file.h>
28: #endif
29:
30: static int le_protocols;
31:
32: struct php_user_stream_wrapper {
33: char * protoname;
34: char * classname;
35: zend_class_entry *ce;
36: php_stream_wrapper wrapper;
37: };
38:
39: static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, char *filename, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC);
40: static int user_wrapper_stat_url(php_stream_wrapper *wrapper, char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC);
41: static int user_wrapper_unlink(php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC);
42: static int user_wrapper_rename(php_stream_wrapper *wrapper, char *url_from, char *url_to, int options, php_stream_context *context TSRMLS_DC);
43: static int user_wrapper_mkdir(php_stream_wrapper *wrapper, char *url, int mode, int options, php_stream_context *context TSRMLS_DC);
44: static int user_wrapper_rmdir(php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC);
45: static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, char *filename, char *mode,
46: int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC);
47:
48: static php_stream_wrapper_ops user_stream_wops = {
49: user_wrapper_opener,
50: NULL, /* close - the streams themselves know how */
51: NULL, /* stat - the streams themselves know how */
52: user_wrapper_stat_url,
53: user_wrapper_opendir,
54: "user-space",
55: user_wrapper_unlink,
56: user_wrapper_rename,
57: user_wrapper_mkdir,
58: user_wrapper_rmdir
59: };
60:
61:
62: static void stream_wrapper_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
63: {
64: struct php_user_stream_wrapper * uwrap = (struct php_user_stream_wrapper*)rsrc->ptr;
65:
66: efree(uwrap->protoname);
67: efree(uwrap->classname);
68: efree(uwrap);
69: }
70:
71:
72: PHP_MINIT_FUNCTION(user_streams)
73: {
74: le_protocols = zend_register_list_destructors_ex(stream_wrapper_dtor, NULL, "stream factory", 0);
75: if (le_protocols == FAILURE)
76: return FAILURE;
77:
78: REGISTER_LONG_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS|CONST_PERSISTENT);
79: REGISTER_LONG_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS|CONST_PERSISTENT);
80: REGISTER_LONG_CONSTANT("STREAM_ENFORCE_SAFE_MODE", ENFORCE_SAFE_MODE, CONST_CS|CONST_PERSISTENT);
81: REGISTER_LONG_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS|CONST_PERSISTENT);
82: REGISTER_LONG_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS|CONST_PERSISTENT);
83:
84: REGISTER_LONG_CONSTANT("STREAM_URL_STAT_LINK", PHP_STREAM_URL_STAT_LINK, CONST_CS|CONST_PERSISTENT);
85: REGISTER_LONG_CONSTANT("STREAM_URL_STAT_QUIET", PHP_STREAM_URL_STAT_QUIET, CONST_CS|CONST_PERSISTENT);
86: REGISTER_LONG_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE, CONST_CS|CONST_PERSISTENT);
87:
88: REGISTER_LONG_CONSTANT("STREAM_IS_URL", PHP_STREAM_IS_URL, CONST_CS|CONST_PERSISTENT);
89:
90: REGISTER_LONG_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING, CONST_CS|CONST_PERSISTENT);
91: REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_TIMEOUT", PHP_STREAM_OPTION_READ_TIMEOUT, CONST_CS|CONST_PERSISTENT);
92: REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_BUFFER", PHP_STREAM_OPTION_READ_BUFFER, CONST_CS|CONST_PERSISTENT);
93: REGISTER_LONG_CONSTANT("STREAM_OPTION_WRITE_BUFFER", PHP_STREAM_OPTION_WRITE_BUFFER, CONST_CS|CONST_PERSISTENT);
94:
95: REGISTER_LONG_CONSTANT("STREAM_BUFFER_NONE", PHP_STREAM_BUFFER_NONE, CONST_CS|CONST_PERSISTENT);
96: REGISTER_LONG_CONSTANT("STREAM_BUFFER_LINE", PHP_STREAM_BUFFER_LINE, CONST_CS|CONST_PERSISTENT);
97: REGISTER_LONG_CONSTANT("STREAM_BUFFER_FULL", PHP_STREAM_BUFFER_FULL, CONST_CS|CONST_PERSISTENT);
98:
99: REGISTER_LONG_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS|CONST_PERSISTENT);
100: REGISTER_LONG_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS|CONST_PERSISTENT);
101:
102: return SUCCESS;
103: }
104:
105: struct _php_userstream_data {
106: struct php_user_stream_wrapper * wrapper;
107: zval * object;
108: };
109: typedef struct _php_userstream_data php_userstream_data_t;
110:
111: /* names of methods */
112: #define USERSTREAM_OPEN "stream_open"
113: #define USERSTREAM_CLOSE "stream_close"
114: #define USERSTREAM_READ "stream_read"
115: #define USERSTREAM_WRITE "stream_write"
116: #define USERSTREAM_FLUSH "stream_flush"
117: #define USERSTREAM_SEEK "stream_seek"
118: #define USERSTREAM_TELL "stream_tell"
119: #define USERSTREAM_EOF "stream_eof"
120: #define USERSTREAM_STAT "stream_stat"
121: #define USERSTREAM_STATURL "url_stat"
122: #define USERSTREAM_UNLINK "unlink"
123: #define USERSTREAM_RENAME "rename"
124: #define USERSTREAM_MKDIR "mkdir"
125: #define USERSTREAM_RMDIR "rmdir"
126: #define USERSTREAM_DIR_OPEN "dir_opendir"
127: #define USERSTREAM_DIR_READ "dir_readdir"
128: #define USERSTREAM_DIR_REWIND "dir_rewinddir"
129: #define USERSTREAM_DIR_CLOSE "dir_closedir"
130: #define USERSTREAM_LOCK "stream_lock"
131: #define USERSTREAM_CAST "stream_cast"
132: #define USERSTREAM_SET_OPTION "stream_set_option"
133:
134: /* {{{ class should have methods like these:
135:
136: function stream_open($path, $mode, $options, &$opened_path)
137: {
138: return true/false;
139: }
140:
141: function stream_read($count)
142: {
143: return false on error;
144: else return string;
145: }
146:
147: function stream_write($data)
148: {
149: return false on error;
150: else return count written;
151: }
152:
153: function stream_close()
154: {
155: }
156:
157: function stream_flush()
158: {
159: return true/false;
160: }
161:
162: function stream_seek($offset, $whence)
163: {
164: return true/false;
165: }
166:
167: function stream_tell()
168: {
169: return (int)$position;
170: }
171:
172: function stream_eof()
173: {
174: return true/false;
175: }
176:
177: function stream_stat()
178: {
179: return array( just like that returned by fstat() );
180: }
181:
182: function stream_cast($castas)
183: {
184: if ($castas == STREAM_CAST_FOR_SELECT) {
185: return $this->underlying_stream;
186: }
187: return false;
188: }
189:
190: function stream_set_option($option, $arg1, $arg2)
191: {
192: switch($option) {
193: case STREAM_OPTION_BLOCKING:
194: $blocking = $arg1;
195: ...
196: case STREAM_OPTION_READ_TIMEOUT:
197: $sec = $arg1;
198: $usec = $arg2;
199: ...
200: case STREAM_OPTION_WRITE_BUFFER:
201: $mode = $arg1;
202: $size = $arg2;
203: ...
204: default:
205: return false;
206: }
207: }
208:
209: function url_stat(string $url, int $flags)
210: {
211: return array( just like that returned by stat() );
212: }
213:
214: function unlink(string $url)
215: {
216: return true / false;
217: }
218:
219: function rename(string $from, string $to)
220: {
221: return true / false;
222: }
223:
224: function mkdir($dir, $mode, $options)
225: {
226: return true / false;
227: }
228:
229: function rmdir($dir, $options)
230: {
231: return true / false;
232: }
233:
234: function dir_opendir(string $url, int $options)
235: {
236: return true / false;
237: }
238:
239: function dir_readdir()
240: {
241: return string next filename in dir ;
242: }
243:
244: function dir_closedir()
245: {
246: release dir related resources;
247: }
248:
249: function dir_rewinddir()
250: {
251: reset to start of dir list;
252: }
253:
254: function stream_lock($operation)
255: {
256: return true / false;
257: }
258:
259: }}} **/
260:
261: static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, char *filename, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
262: {
263: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
264: php_userstream_data_t *us;
265: zval *zfilename, *zmode, *zopened, *zoptions, *zretval = NULL, *zfuncname;
266: zval **args[4];
267: int call_result;
268: php_stream *stream = NULL;
269: zend_bool old_in_user_include;
270:
271: /* Try to catch bad usage without preventing flexibility */
272: if (FG(user_stream_current_filename) != NULL && strcmp(filename, FG(user_stream_current_filename)) == 0) {
273: php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "infinite recursion prevented");
274: return NULL;
275: }
276: FG(user_stream_current_filename) = filename;
277:
278: /* if the user stream was registered as local and we are in include context,
279: we add allow_url_include restrictions to allow_url_fopen ones */
280: /* we need only is_url == 0 here since if is_url == 1 and remote wrappers
281: were restricted we wouldn't get here */
282: old_in_user_include = PG(in_user_include);
283: if(uwrap->wrapper.is_url == 0 &&
284: (options & STREAM_OPEN_FOR_INCLUDE) &&
285: !PG(allow_url_include)) {
286: PG(in_user_include) = 1;
287: }
288:
289: us = emalloc(sizeof(*us));
290: us->wrapper = uwrap;
291:
292: /* create an instance of our class */
293: ALLOC_ZVAL(us->object);
294: object_init_ex(us->object, uwrap->ce);
295: Z_SET_REFCOUNT_P(us->object, 1);
296: Z_SET_ISREF_P(us->object);
297:
298: if (uwrap->ce->constructor) {
299: zend_fcall_info fci;
300: zend_fcall_info_cache fcc;
301: zval *retval_ptr;
302:
303: fci.size = sizeof(fci);
304: fci.function_table = &uwrap->ce->function_table;
305: fci.function_name = NULL;
306: fci.symbol_table = NULL;
307: fci.object_ptr = us->object;
308: fci.retval_ptr_ptr = &retval_ptr;
309: fci.param_count = 0;
310: fci.params = NULL;
311: fci.no_separation = 1;
312:
313: fcc.initialized = 1;
314: fcc.function_handler = uwrap->ce->constructor;
315: fcc.calling_scope = EG(scope);
316: fcc.called_scope = Z_OBJCE_P(us->object);
317: fcc.object_ptr = us->object;
318:
319: if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
320: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute %s::%s()", uwrap->ce->name, uwrap->ce->constructor->common.function_name);
321: zval_dtor(us->object);
322: FREE_ZVAL(us->object);
323: efree(us);
324: FG(user_stream_current_filename) = NULL;
325: PG(in_user_include) = old_in_user_include;
326: return NULL;
327: } else {
328: if (retval_ptr) {
329: zval_ptr_dtor(&retval_ptr);
330: }
331: }
332: }
333:
334: if (context) {
335: add_property_resource(us->object, "context", context->rsrc_id);
336: zend_list_addref(context->rsrc_id);
337: } else {
338: add_property_null(us->object, "context");
339: }
340:
341: /* call it's stream_open method - set up params first */
342: MAKE_STD_ZVAL(zfilename);
343: ZVAL_STRING(zfilename, filename, 1);
344: args[0] = &zfilename;
345:
346: MAKE_STD_ZVAL(zmode);
347: ZVAL_STRING(zmode, mode, 1);
348: args[1] = &zmode;
349:
350: MAKE_STD_ZVAL(zoptions);
351: ZVAL_LONG(zoptions, options);
352: args[2] = &zoptions;
353:
354: MAKE_STD_ZVAL(zopened);
355: Z_SET_REFCOUNT_P(zopened, 1);
356: Z_SET_ISREF_P(zopened);
357: ZVAL_NULL(zopened);
358: args[3] = &zopened;
359:
360: MAKE_STD_ZVAL(zfuncname);
361: ZVAL_STRING(zfuncname, USERSTREAM_OPEN, 1);
362:
363: call_result = call_user_function_ex(NULL,
364: &us->object,
365: zfuncname,
366: &zretval,
367: 4, args,
368: 0, NULL TSRMLS_CC);
369:
370: if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
371: /* the stream is now open! */
372: stream = php_stream_alloc_rel(&php_stream_userspace_ops, us, 0, mode);
373:
374: /* if the opened path is set, copy it out */
375: if (Z_TYPE_P(zopened) == IS_STRING && opened_path) {
376: *opened_path = estrndup(Z_STRVAL_P(zopened), Z_STRLEN_P(zopened));
377: }
378:
379: /* set wrapper data to be a reference to our object */
380: stream->wrapperdata = us->object;
381: zval_add_ref(&stream->wrapperdata);
382: } else {
383: php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_OPEN "\" call failed",
384: us->wrapper->classname);
385: }
386:
387: /* destroy everything else */
388: if (stream == NULL) {
389: zval_ptr_dtor(&us->object);
390: efree(us);
391: }
392: if (zretval)
393: zval_ptr_dtor(&zretval);
394:
395: zval_ptr_dtor(&zfuncname);
396: zval_ptr_dtor(&zopened);
397: zval_ptr_dtor(&zoptions);
398: zval_ptr_dtor(&zmode);
399: zval_ptr_dtor(&zfilename);
400:
401: FG(user_stream_current_filename) = NULL;
402:
403: PG(in_user_include) = old_in_user_include;
404: return stream;
405: }
406:
407: static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, char *filename, char *mode,
408: int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
409: {
410: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
411: php_userstream_data_t *us;
412: zval *zfilename, *zoptions, *zretval = NULL, *zfuncname;
413: zval **args[2];
414: int call_result;
415: php_stream *stream = NULL;
416:
417: /* Try to catch bad usage without preventing flexibility */
418: if (FG(user_stream_current_filename) != NULL && strcmp(filename, FG(user_stream_current_filename)) == 0) {
419: php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "infinite recursion prevented");
420: return NULL;
421: }
422: FG(user_stream_current_filename) = filename;
423:
424: us = emalloc(sizeof(*us));
425: us->wrapper = uwrap;
426:
427: /* create an instance of our class */
428: ALLOC_ZVAL(us->object);
429: object_init_ex(us->object, uwrap->ce);
430: Z_SET_REFCOUNT_P(us->object, 1);
431: Z_SET_ISREF_P(us->object);
432:
433: if (context) {
434: add_property_resource(us->object, "context", context->rsrc_id);
435: zend_list_addref(context->rsrc_id);
436: } else {
437: add_property_null(us->object, "context");
438: }
439:
440: /* call it's dir_open method - set up params first */
441: MAKE_STD_ZVAL(zfilename);
442: ZVAL_STRING(zfilename, filename, 1);
443: args[0] = &zfilename;
444:
445: MAKE_STD_ZVAL(zoptions);
446: ZVAL_LONG(zoptions, options);
447: args[1] = &zoptions;
448:
449: MAKE_STD_ZVAL(zfuncname);
450: ZVAL_STRING(zfuncname, USERSTREAM_DIR_OPEN, 1);
451:
452: call_result = call_user_function_ex(NULL,
453: &us->object,
454: zfuncname,
455: &zretval,
456: 2, args,
457: 0, NULL TSRMLS_CC);
458:
459: if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
460: /* the stream is now open! */
461: stream = php_stream_alloc_rel(&php_stream_userspace_dir_ops, us, 0, mode);
462:
463: /* set wrapper data to be a reference to our object */
464: stream->wrapperdata = us->object;
465: zval_add_ref(&stream->wrapperdata);
466: } else {
467: php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_DIR_OPEN "\" call failed",
468: us->wrapper->classname);
469: }
470:
471: /* destroy everything else */
472: if (stream == NULL) {
473: zval_ptr_dtor(&us->object);
474: efree(us);
475: }
476: if (zretval)
477: zval_ptr_dtor(&zretval);
478:
479: zval_ptr_dtor(&zfuncname);
480: zval_ptr_dtor(&zoptions);
481: zval_ptr_dtor(&zfilename);
482:
483: FG(user_stream_current_filename) = NULL;
484:
485: return stream;
486: }
487:
488:
489: /* {{{ proto bool stream_wrapper_register(string protocol, string classname[, integer flags])
490: Registers a custom URL protocol handler class */
491: PHP_FUNCTION(stream_wrapper_register)
492: {
493: char *protocol, *classname;
494: int protocol_len, classname_len;
495: struct php_user_stream_wrapper * uwrap;
496: int rsrc_id;
497: long flags = 0;
498:
499: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &protocol, &protocol_len, &classname, &classname_len, &flags) == FAILURE) {
500: RETURN_FALSE;
501: }
502:
503: uwrap = (struct php_user_stream_wrapper *)ecalloc(1, sizeof(*uwrap));
504: uwrap->protoname = estrndup(protocol, protocol_len);
505: uwrap->classname = estrndup(classname, classname_len);
506: uwrap->wrapper.wops = &user_stream_wops;
507: uwrap->wrapper.abstract = uwrap;
508: uwrap->wrapper.is_url = ((flags & PHP_STREAM_IS_URL) != 0);
509:
510: rsrc_id = ZEND_REGISTER_RESOURCE(NULL, uwrap, le_protocols);
511:
512: if (zend_lookup_class(uwrap->classname, classname_len, (zend_class_entry***)&uwrap->ce TSRMLS_CC) == SUCCESS) {
513: uwrap->ce = *(zend_class_entry**)uwrap->ce;
514: if (php_register_url_stream_wrapper_volatile(protocol, &uwrap->wrapper TSRMLS_CC) == SUCCESS) {
515: RETURN_TRUE;
516: } else {
517: /* We failed. But why? */
518: if (zend_hash_exists(php_stream_get_url_stream_wrappers_hash(), protocol, protocol_len + 1)) {
519: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Protocol %s:// is already defined.", protocol);
520: } else {
521: /* Hash doesn't exist so it must have been an invalid protocol scheme */
522: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid protocol scheme specified. Unable to register wrapper class %s to %s://", classname, protocol);
523: }
524: }
525: } else {
526: php_error_docref(NULL TSRMLS_CC, E_WARNING, "class '%s' is undefined", classname);
527: }
528:
529: zend_list_delete(rsrc_id);
530: RETURN_FALSE;
531: }
532: /* }}} */
533:
534: /* {{{ proto bool stream_wrapper_unregister(string protocol)
535: Unregister a wrapper for the life of the current request. */
536: PHP_FUNCTION(stream_wrapper_unregister)
537: {
538: char *protocol;
539: int protocol_len;
540:
541: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &protocol, &protocol_len) == FAILURE) {
542: RETURN_FALSE;
543: }
544:
545: if (php_unregister_url_stream_wrapper_volatile(protocol TSRMLS_CC) == FAILURE) {
546: /* We failed */
547: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to unregister protocol %s://", protocol);
548: RETURN_FALSE;
549: }
550:
551: RETURN_TRUE;
552: }
553: /* }}} */
554:
555: /* {{{ proto bool stream_wrapper_restore(string protocol)
556: Restore the original protocol handler, overriding if necessary */
557: PHP_FUNCTION(stream_wrapper_restore)
558: {
559: char *protocol;
560: int protocol_len;
561: php_stream_wrapper **wrapperpp = NULL, *wrapper;
562: HashTable *global_wrapper_hash;
563:
564: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &protocol, &protocol_len) == FAILURE) {
565: RETURN_FALSE;
566: }
567:
568: global_wrapper_hash = php_stream_get_url_stream_wrappers_hash_global();
569: if (php_stream_get_url_stream_wrappers_hash() == global_wrapper_hash) {
570: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s:// was never changed, nothing to restore", protocol);
571: RETURN_TRUE;
572: }
573:
574: if ((zend_hash_find(global_wrapper_hash, protocol, protocol_len + 1, (void**)&wrapperpp) == FAILURE) || !wrapperpp) {
575: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// never existed, nothing to restore", protocol);
576: RETURN_FALSE;
577: }
578:
579: /* next line might delete the pointer that wrapperpp points at, so deref it now */
580: wrapper = *wrapperpp;
581:
582: /* A failure here could be okay given that the protocol might have been merely unregistered */
583: php_unregister_url_stream_wrapper_volatile(protocol TSRMLS_CC);
584:
585: if (php_register_url_stream_wrapper_volatile(protocol, wrapper TSRMLS_CC) == FAILURE) {
586: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to restore original %s:// wrapper", protocol);
587: RETURN_FALSE;
588: }
589:
590: RETURN_TRUE;
591: }
592: /* }}} */
593:
594: static size_t php_userstreamop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
595: {
596: zval func_name;
597: zval *retval = NULL;
598: int call_result;
599: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
600: zval **args[1];
601: zval *zbufptr;
602: size_t didwrite = 0;
603:
604: assert(us != NULL);
605:
606: ZVAL_STRINGL(&func_name, USERSTREAM_WRITE, sizeof(USERSTREAM_WRITE)-1, 0);
607:
608: MAKE_STD_ZVAL(zbufptr);
609: ZVAL_STRINGL(zbufptr, (char*)buf, count, 1);;
610: args[0] = &zbufptr;
611:
612: call_result = call_user_function_ex(NULL,
613: &us->object,
614: &func_name,
615: &retval,
616: 1, args,
617: 0, NULL TSRMLS_CC);
618: zval_ptr_dtor(&zbufptr);
619:
620: didwrite = 0;
621: if (call_result == SUCCESS && retval != NULL) {
622: convert_to_long(retval);
623: didwrite = Z_LVAL_P(retval);
624: } else if (call_result == FAILURE) {
625: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " is not implemented!",
626: us->wrapper->classname);
627: }
628:
629: /* don't allow strange buffer overruns due to bogus return */
630: if (didwrite > count) {
631: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " wrote %ld bytes more data than requested (%ld written, %ld max)",
632: us->wrapper->classname,
633: (long)(didwrite - count), (long)didwrite, (long)count);
634: didwrite = count;
635: }
636:
637: if (retval)
638: zval_ptr_dtor(&retval);
639:
640: return didwrite;
641: }
642:
643: static size_t php_userstreamop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
644: {
645: zval func_name;
646: zval *retval = NULL;
647: zval **args[1];
648: int call_result;
649: size_t didread = 0;
650: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
651: zval *zcount;
652:
653: assert(us != NULL);
654:
655: ZVAL_STRINGL(&func_name, USERSTREAM_READ, sizeof(USERSTREAM_READ)-1, 0);
656:
657: MAKE_STD_ZVAL(zcount);
658: ZVAL_LONG(zcount, count);
659: args[0] = &zcount;
660:
661: call_result = call_user_function_ex(NULL,
662: &us->object,
663: &func_name,
664: &retval,
665: 1, args,
666: 0, NULL TSRMLS_CC);
667:
668: if (call_result == SUCCESS && retval != NULL) {
669: convert_to_string(retval);
670: didread = Z_STRLEN_P(retval);
671: if (didread > count) {
672: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read %ld bytes more data than requested (%ld read, %ld max) - excess data will be lost",
673: us->wrapper->classname, (long)(didread - count), (long)didread, (long)count);
674: didread = count;
675: }
676: if (didread > 0)
677: memcpy(buf, Z_STRVAL_P(retval), didread);
678: } else if (call_result == FAILURE) {
679: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " is not implemented!",
680: us->wrapper->classname);
681: }
682: zval_ptr_dtor(&zcount);
683:
684: if (retval) {
685: zval_ptr_dtor(&retval);
686: retval = NULL;
687: }
688:
689: /* since the user stream has no way of setting the eof flag directly, we need to ask it if we hit eof */
690:
691: ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1, 0);
692:
693: call_result = call_user_function_ex(NULL,
694: &us->object,
695: &func_name,
696: &retval,
697: 0, NULL, 0, NULL TSRMLS_CC);
698:
699: if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
700: stream->eof = 1;
701: } else if (call_result == FAILURE) {
702: php_error_docref(NULL TSRMLS_CC, E_WARNING,
703: "%s::" USERSTREAM_EOF " is not implemented! Assuming EOF",
704: us->wrapper->classname);
705:
706: stream->eof = 1;
707: }
708:
709: if (retval) {
710: zval_ptr_dtor(&retval);
711: retval = NULL;
712: }
713:
714: return didread;
715: }
716:
717: static int php_userstreamop_close(php_stream *stream, int close_handle TSRMLS_DC)
718: {
719: zval func_name;
720: zval *retval = NULL;
721: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
722:
723: assert(us != NULL);
724:
725: ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1, 0);
726:
727: call_user_function_ex(NULL,
728: &us->object,
729: &func_name,
730: &retval,
731: 0, NULL, 0, NULL TSRMLS_CC);
732:
733: if (retval)
734: zval_ptr_dtor(&retval);
735:
736: zval_ptr_dtor(&us->object);
737:
738: efree(us);
739:
740: return 0;
741: }
742:
743: static int php_userstreamop_flush(php_stream *stream TSRMLS_DC)
744: {
745: zval func_name;
746: zval *retval = NULL;
747: int call_result;
748: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
749:
750: assert(us != NULL);
751:
752: ZVAL_STRINGL(&func_name, USERSTREAM_FLUSH, sizeof(USERSTREAM_FLUSH)-1, 0);
753:
754: call_result = call_user_function_ex(NULL,
755: &us->object,
756: &func_name,
757: &retval,
758: 0, NULL, 0, NULL TSRMLS_CC);
759:
760: if (call_result == SUCCESS && retval != NULL && zval_is_true(retval))
761: call_result = 0;
762: else
763: call_result = -1;
764:
765: if (retval)
766: zval_ptr_dtor(&retval);
767:
768: return call_result;
769: }
770:
771: static int php_userstreamop_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
772: {
773: zval func_name;
774: zval *retval = NULL;
775: int call_result, ret;
776: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
777: zval **args[2];
778: zval *zoffs, *zwhence;
779:
780: assert(us != NULL);
781:
782: ZVAL_STRINGL(&func_name, USERSTREAM_SEEK, sizeof(USERSTREAM_SEEK)-1, 0);
783:
784: MAKE_STD_ZVAL(zoffs);
785: ZVAL_LONG(zoffs, offset);
786: args[0] = &zoffs;
787:
788: MAKE_STD_ZVAL(zwhence);
789: ZVAL_LONG(zwhence, whence);
790: args[1] = &zwhence;
791:
792: call_result = call_user_function_ex(NULL,
793: &us->object,
794: &func_name,
795: &retval,
796: 2, args,
797: 0, NULL TSRMLS_CC);
798:
799: zval_ptr_dtor(&zoffs);
800: zval_ptr_dtor(&zwhence);
801:
802: if (call_result == FAILURE) {
803: /* stream_seek is not implemented, so disable seeks for this stream */
804: stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
805: /* there should be no retval to clean up */
806:
807: if (retval)
808: zval_ptr_dtor(&retval);
809:
810: return -1;
811: } else if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
812: ret = 0;
813: } else {
814: ret = -1;
815: }
816:
817: if (retval) {
818: zval_ptr_dtor(&retval);
819: retval = NULL;
820: }
821:
822: if (ret) {
823: return ret;
824: }
825:
826: /* now determine where we are */
827: ZVAL_STRINGL(&func_name, USERSTREAM_TELL, sizeof(USERSTREAM_TELL)-1, 0);
828:
829: call_result = call_user_function_ex(NULL,
830: &us->object,
831: &func_name,
832: &retval,
833: 0, NULL, 0, NULL TSRMLS_CC);
834:
835: if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_LONG) {
836: *newoffs = Z_LVAL_P(retval);
837: ret = 0;
838: } else if (call_result == FAILURE) {
839: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", us->wrapper->classname);
840: ret = -1;
841: } else {
842: ret = -1;
843: }
844:
845: if (retval) {
846: zval_ptr_dtor(&retval);
847: }
848: return ret;
849: }
850:
851: /* parse the return value from one of the stat functions and store the
852: * relevant fields into the statbuf provided */
853: static int statbuf_from_array(zval *array, php_stream_statbuf *ssb TSRMLS_DC)
854: {
855: zval **elem;
856:
857: #define STAT_PROP_ENTRY_EX(name, name2) \
858: if (SUCCESS == zend_hash_find(Z_ARRVAL_P(array), #name, sizeof(#name), (void**)&elem)) { \
859: SEPARATE_ZVAL(elem); \
860: convert_to_long(*elem); \
861: ssb->sb.st_##name2 = Z_LVAL_PP(elem); \
862: }
863:
864: #define STAT_PROP_ENTRY(name) STAT_PROP_ENTRY_EX(name,name)
865:
866: memset(ssb, 0, sizeof(php_stream_statbuf));
867: STAT_PROP_ENTRY(dev);
868: STAT_PROP_ENTRY(ino);
869: STAT_PROP_ENTRY(mode);
870: STAT_PROP_ENTRY(nlink);
871: STAT_PROP_ENTRY(uid);
872: STAT_PROP_ENTRY(gid);
873: #if HAVE_ST_RDEV
874: STAT_PROP_ENTRY(rdev);
875: #endif
876: STAT_PROP_ENTRY(size);
877: #ifdef NETWARE
878: STAT_PROP_ENTRY_EX(atime, atime.tv_sec);
879: STAT_PROP_ENTRY_EX(mtime, mtime.tv_sec);
880: STAT_PROP_ENTRY_EX(ctime, ctime.tv_sec);
881: #else
882: STAT_PROP_ENTRY(atime);
883: STAT_PROP_ENTRY(mtime);
884: STAT_PROP_ENTRY(ctime);
885: #endif
886: #ifdef HAVE_ST_BLKSIZE
887: STAT_PROP_ENTRY(blksize);
888: #endif
889: #ifdef HAVE_ST_BLOCKS
890: STAT_PROP_ENTRY(blocks);
891: #endif
892:
893: #undef STAT_PROP_ENTRY
894: #undef STAT_PROP_ENTRY_EX
895: return SUCCESS;
896: }
897:
898: static int php_userstreamop_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
899: {
900: zval func_name;
901: zval *retval = NULL;
902: int call_result;
903: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
904: int ret = -1;
905:
906: ZVAL_STRINGL(&func_name, USERSTREAM_STAT, sizeof(USERSTREAM_STAT)-1, 0);
907:
908: call_result = call_user_function_ex(NULL,
909: &us->object,
910: &func_name,
911: &retval,
912: 0, NULL, 0, NULL TSRMLS_CC);
913:
914: if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_ARRAY) {
915: if (SUCCESS == statbuf_from_array(retval, ssb TSRMLS_CC))
916: ret = 0;
917: } else {
918: if (call_result == FAILURE) {
919: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_STAT " is not implemented!",
920: us->wrapper->classname);
921: }
922: }
923:
924: if (retval)
925: zval_ptr_dtor(&retval);
926:
927: return ret;
928: }
929:
930:
931: static int php_userstreamop_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC) {
932: zval func_name;
933: zval *retval = NULL;
934: int call_result;
935: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
936: int ret = -1;
937: zval *zvalue = NULL;
938: zval **args[3];
939:
940: switch (option) {
941: case PHP_STREAM_OPTION_CHECK_LIVENESS:
942: ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1, 0);
943: call_result = call_user_function_ex(NULL, &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
944: if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
945: ret = zval_is_true(retval) ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
946: } else {
947: ret = PHP_STREAM_OPTION_RETURN_ERR;
948: php_error_docref(NULL TSRMLS_CC, E_WARNING,
949: "%s::" USERSTREAM_EOF " is not implemented! Assuming EOF",
950: us->wrapper->classname);
951: }
952: break;
953:
954: case PHP_STREAM_OPTION_LOCKING:
955: MAKE_STD_ZVAL(zvalue);
956: ZVAL_LONG(zvalue, 0);
957:
958: if (value & LOCK_NB) {
959: Z_LVAL_P(zvalue) |= PHP_LOCK_NB;
960: }
961: switch(value & ~LOCK_NB) {
962: case LOCK_SH:
963: Z_LVAL_P(zvalue) |= PHP_LOCK_SH;
964: break;
965: case LOCK_EX:
966: Z_LVAL_P(zvalue) |= PHP_LOCK_EX;
967: break;
968: case LOCK_UN:
969: Z_LVAL_P(zvalue) |= PHP_LOCK_UN;
970: break;
971: }
972:
973: args[0] = &zvalue;
974:
975: /* TODO wouldblock */
976: ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1, 0);
977:
978: call_result = call_user_function_ex(NULL,
979: &us->object,
980: &func_name,
981: &retval,
982: 1, args, 0, NULL TSRMLS_CC);
983:
984: if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
985: ret = !Z_LVAL_P(retval);
986: } else if (call_result == FAILURE) {
987: if (value == 0) {
988: /* lock support test (TODO: more check) */
989: ret = 0;
990: } else {
991: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_LOCK " is not implemented!",
992: us->wrapper->classname);
993: }
994: }
995:
996: break;
997:
998: case PHP_STREAM_OPTION_READ_BUFFER:
999: case PHP_STREAM_OPTION_WRITE_BUFFER:
1000: case PHP_STREAM_OPTION_READ_TIMEOUT:
1001: case PHP_STREAM_OPTION_BLOCKING: {
1002: zval *zoption = NULL;
1003: zval *zptrparam = NULL;
1004:
1005: ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1, 0);
1006:
1007: ALLOC_INIT_ZVAL(zoption);
1008: ZVAL_LONG(zoption, option);
1009:
1010: ALLOC_INIT_ZVAL(zvalue);
1011: ALLOC_INIT_ZVAL(zptrparam);
1012:
1013: args[0] = &zoption;
1014: args[1] = &zvalue;
1015: args[2] = &zptrparam;
1016:
1017: switch(option) {
1018: case PHP_STREAM_OPTION_READ_BUFFER:
1019: case PHP_STREAM_OPTION_WRITE_BUFFER:
1020: ZVAL_LONG(zvalue, value);
1021: if (ptrparam) {
1022: ZVAL_LONG(zptrparam, *(long *)ptrparam);
1023: } else {
1024: ZVAL_LONG(zptrparam, BUFSIZ);
1025: }
1026: break;
1027: case PHP_STREAM_OPTION_READ_TIMEOUT: {
1028: struct timeval tv = *(struct timeval*)ptrparam;
1029: ZVAL_LONG(zvalue, tv.tv_sec);
1030: ZVAL_LONG(zptrparam, tv.tv_usec);
1031: break;
1032: }
1033: case PHP_STREAM_OPTION_BLOCKING:
1034: ZVAL_LONG(zvalue, value);
1035: break;
1036: default:
1037: break;
1038: }
1039:
1040: call_result = call_user_function_ex(NULL,
1041: &us->object,
1042: &func_name,
1043: &retval,
1044: 3, args, 0, NULL TSRMLS_CC);
1045:
1046: do {
1047: if (call_result == FAILURE) {
1048: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_SET_OPTION " is not implemented!",
1049: us->wrapper->classname);
1050: break;
1051: }
1052: if (retval && zend_is_true(retval)) {
1053: ret = PHP_STREAM_OPTION_RETURN_OK;
1054: }
1055: } while (0);
1056:
1057: if (zoption) {
1058: zval_ptr_dtor(&zoption);
1059: }
1060: if (zptrparam) {
1061: zval_ptr_dtor(&zptrparam);
1062: }
1063:
1064: break;
1065: }
1066: }
1067:
1068: /* clean up */
1069: if (retval) {
1070: zval_ptr_dtor(&retval);
1071: }
1072:
1073:
1074: if (zvalue) {
1075: zval_ptr_dtor(&zvalue);
1076: }
1077:
1078: return ret;
1079: }
1080:
1081:
1082: static int user_wrapper_unlink(php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC)
1083: {
1084: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
1085: zval *zfilename, *zfuncname, *zretval;
1086: zval **args[1];
1087: int call_result;
1088: zval *object;
1089: int ret = 0;
1090:
1091: /* create an instance of our class */
1092: ALLOC_ZVAL(object);
1093: object_init_ex(object, uwrap->ce);
1094: Z_SET_REFCOUNT_P(object, 1);
1095: Z_SET_ISREF_P(object);
1096:
1097: if (context) {
1098: add_property_resource(object, "context", context->rsrc_id);
1099: zend_list_addref(context->rsrc_id);
1100: } else {
1101: add_property_null(object, "context");
1102: }
1103:
1104: /* call the unlink method */
1105: MAKE_STD_ZVAL(zfilename);
1106: ZVAL_STRING(zfilename, url, 1);
1107: args[0] = &zfilename;
1108:
1109: MAKE_STD_ZVAL(zfuncname);
1110: ZVAL_STRING(zfuncname, USERSTREAM_UNLINK, 1);
1111:
1112: call_result = call_user_function_ex(NULL,
1113: &object,
1114: zfuncname,
1115: &zretval,
1116: 1, args,
1117: 0, NULL TSRMLS_CC);
1118:
1119: if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
1120: ret = Z_LVAL_P(zretval);
1121: } else if (call_result == FAILURE) {
1122: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_UNLINK " is not implemented!", uwrap->classname);
1123: }
1124:
1125: /* clean up */
1126: zval_ptr_dtor(&object);
1127: if (zretval)
1128: zval_ptr_dtor(&zretval);
1129:
1130: zval_ptr_dtor(&zfuncname);
1131: zval_ptr_dtor(&zfilename);
1132:
1133: return ret;
1134: }
1135:
1136: static int user_wrapper_rename(php_stream_wrapper *wrapper, char *url_from, char *url_to, int options, php_stream_context *context TSRMLS_DC)
1137: {
1138: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
1139: zval *zold_name, *znew_name, *zfuncname, *zretval;
1140: zval **args[2];
1141: int call_result;
1142: zval *object;
1143: int ret = 0;
1144:
1145: /* create an instance of our class */
1146: ALLOC_ZVAL(object);
1147: object_init_ex(object, uwrap->ce);
1148: Z_SET_REFCOUNT_P(object, 1);
1149: Z_SET_ISREF_P(object);
1150:
1151: if (context) {
1152: add_property_resource(object, "context", context->rsrc_id);
1153: zend_list_addref(context->rsrc_id);
1154: } else {
1155: add_property_null(object, "context");
1156: }
1157:
1158: /* call the rename method */
1159: MAKE_STD_ZVAL(zold_name);
1160: ZVAL_STRING(zold_name, url_from, 1);
1161: args[0] = &zold_name;
1162:
1163: MAKE_STD_ZVAL(znew_name);
1164: ZVAL_STRING(znew_name, url_to, 1);
1165: args[1] = &znew_name;
1166:
1167: MAKE_STD_ZVAL(zfuncname);
1168: ZVAL_STRING(zfuncname, USERSTREAM_RENAME, 1);
1169:
1170: call_result = call_user_function_ex(NULL,
1171: &object,
1172: zfuncname,
1173: &zretval,
1174: 2, args,
1175: 0, NULL TSRMLS_CC);
1176:
1177: if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
1178: ret = Z_LVAL_P(zretval);
1179: } else if (call_result == FAILURE) {
1180: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_RENAME " is not implemented!", uwrap->classname);
1181: }
1182:
1183: /* clean up */
1184: zval_ptr_dtor(&object);
1185: if (zretval)
1186: zval_ptr_dtor(&zretval);
1187:
1188: zval_ptr_dtor(&zfuncname);
1189: zval_ptr_dtor(&zold_name);
1190: zval_ptr_dtor(&znew_name);
1191:
1192: return ret;
1193: }
1194:
1195: static int user_wrapper_mkdir(php_stream_wrapper *wrapper, char *url, int mode, int options, php_stream_context *context TSRMLS_DC)
1196: {
1197: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
1198: zval *zfilename, *zmode, *zoptions, *zfuncname, *zretval;
1199: zval **args[3];
1200: int call_result;
1201: zval *object;
1202: int ret = 0;
1203:
1204: /* create an instance of our class */
1205: ALLOC_ZVAL(object);
1206: object_init_ex(object, uwrap->ce);
1207: Z_SET_REFCOUNT_P(object, 1);
1208: Z_SET_ISREF_P(object);
1209:
1210: if (context) {
1211: add_property_resource(object, "context", context->rsrc_id);
1212: zend_list_addref(context->rsrc_id);
1213: } else {
1214: add_property_null(object, "context");
1215: }
1216:
1217: /* call the mkdir method */
1218: MAKE_STD_ZVAL(zfilename);
1219: ZVAL_STRING(zfilename, url, 1);
1220: args[0] = &zfilename;
1221:
1222: MAKE_STD_ZVAL(zmode);
1223: ZVAL_LONG(zmode, mode);
1224: args[1] = &zmode;
1225:
1226: MAKE_STD_ZVAL(zoptions);
1227: ZVAL_LONG(zoptions, options);
1228: args[2] = &zoptions;
1229:
1230: MAKE_STD_ZVAL(zfuncname);
1231: ZVAL_STRING(zfuncname, USERSTREAM_MKDIR, 1);
1232:
1233: call_result = call_user_function_ex(NULL,
1234: &object,
1235: zfuncname,
1236: &zretval,
1237: 3, args,
1238: 0, NULL TSRMLS_CC);
1239:
1240: if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
1241: ret = Z_LVAL_P(zretval);
1242: } else if (call_result == FAILURE) {
1243: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_MKDIR " is not implemented!", uwrap->classname);
1244: }
1245:
1246: /* clean up */
1247: zval_ptr_dtor(&object);
1248: if (zretval) {
1249: zval_ptr_dtor(&zretval);
1250: }
1251:
1252: zval_ptr_dtor(&zfuncname);
1253: zval_ptr_dtor(&zfilename);
1254: zval_ptr_dtor(&zmode);
1255: zval_ptr_dtor(&zoptions);
1256:
1257: return ret;
1258: }
1259:
1260: static int user_wrapper_rmdir(php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC)
1261: {
1262: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
1263: zval *zfilename, *zoptions, *zfuncname, *zretval;
1264: zval **args[3];
1265: int call_result;
1266: zval *object;
1267: int ret = 0;
1268:
1269: /* create an instance of our class */
1270: ALLOC_ZVAL(object);
1271: object_init_ex(object, uwrap->ce);
1272: Z_SET_REFCOUNT_P(object, 1);
1273: Z_SET_ISREF_P(object);
1274:
1275: if (context) {
1276: add_property_resource(object, "context", context->rsrc_id);
1277: zend_list_addref(context->rsrc_id);
1278: } else {
1279: add_property_null(object, "context");
1280: }
1281:
1282: /* call the rmdir method */
1283: MAKE_STD_ZVAL(zfilename);
1284: ZVAL_STRING(zfilename, url, 1);
1285: args[0] = &zfilename;
1286:
1287: MAKE_STD_ZVAL(zoptions);
1288: ZVAL_LONG(zoptions, options);
1289: args[1] = &zoptions;
1290:
1291: MAKE_STD_ZVAL(zfuncname);
1292: ZVAL_STRING(zfuncname, USERSTREAM_RMDIR, 1);
1293:
1294: call_result = call_user_function_ex(NULL,
1295: &object,
1296: zfuncname,
1297: &zretval,
1298: 2, args,
1299: 0, NULL TSRMLS_CC);
1300:
1301: if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
1302: ret = Z_LVAL_P(zretval);
1303: } else if (call_result == FAILURE) {
1304: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_RMDIR " is not implemented!", uwrap->classname);
1305: }
1306:
1307: /* clean up */
1308: zval_ptr_dtor(&object);
1309: if (zretval) {
1310: zval_ptr_dtor(&zretval);
1311: }
1312:
1313: zval_ptr_dtor(&zfuncname);
1314: zval_ptr_dtor(&zfilename);
1315: zval_ptr_dtor(&zoptions);
1316:
1317: return ret;
1318: }
1319:
1320: static int user_wrapper_stat_url(php_stream_wrapper *wrapper, char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
1321: {
1322: struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
1323: zval *zfilename, *zfuncname, *zretval, *zflags;
1324: zval **args[2];
1325: int call_result;
1326: zval *object;
1327: int ret = -1;
1328:
1329: /* create an instance of our class */
1330: ALLOC_ZVAL(object);
1331: object_init_ex(object, uwrap->ce);
1332: Z_SET_REFCOUNT_P(object, 1);
1333: Z_SET_ISREF_P(object);
1334:
1335: if (context) {
1336: add_property_resource(object, "context", context->rsrc_id);
1337: zend_list_addref(context->rsrc_id);
1338: } else {
1339: add_property_null(object, "context");
1340: }
1341:
1342: /* call it's stat_url method - set up params first */
1343: MAKE_STD_ZVAL(zfilename);
1344: ZVAL_STRING(zfilename, url, 1);
1345: args[0] = &zfilename;
1346:
1347: MAKE_STD_ZVAL(zflags);
1348: ZVAL_LONG(zflags, flags);
1349: args[1] = &zflags;
1350:
1351: MAKE_STD_ZVAL(zfuncname);
1352: ZVAL_STRING(zfuncname, USERSTREAM_STATURL, 1);
1353:
1354: call_result = call_user_function_ex(NULL,
1355: &object,
1356: zfuncname,
1357: &zretval,
1358: 2, args,
1359: 0, NULL TSRMLS_CC);
1360:
1361: if (call_result == SUCCESS && zretval != NULL && Z_TYPE_P(zretval) == IS_ARRAY) {
1362: /* We got the info we needed */
1363: if (SUCCESS == statbuf_from_array(zretval, ssb TSRMLS_CC))
1364: ret = 0;
1365: } else {
1366: if (call_result == FAILURE) {
1367: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_STATURL " is not implemented!",
1368: uwrap->classname);
1369: }
1370: }
1371:
1372: /* clean up */
1373: zval_ptr_dtor(&object);
1374: if (zretval)
1375: zval_ptr_dtor(&zretval);
1376:
1377: zval_ptr_dtor(&zfuncname);
1378: zval_ptr_dtor(&zfilename);
1379: zval_ptr_dtor(&zflags);
1380:
1381: return ret;
1382:
1383: }
1384:
1385: static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t count TSRMLS_DC)
1386: {
1387: zval func_name;
1388: zval *retval = NULL;
1389: int call_result;
1390: size_t didread = 0;
1391: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
1392: php_stream_dirent *ent = (php_stream_dirent*)buf;
1393:
1394: /* avoid problems if someone mis-uses the stream */
1395: if (count != sizeof(php_stream_dirent))
1396: return 0;
1397:
1398: ZVAL_STRINGL(&func_name, USERSTREAM_DIR_READ, sizeof(USERSTREAM_DIR_READ)-1, 0);
1399:
1400: call_result = call_user_function_ex(NULL,
1401: &us->object,
1402: &func_name,
1403: &retval,
1404: 0, NULL,
1405: 0, NULL TSRMLS_CC);
1406:
1407: if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) != IS_BOOL) {
1408: convert_to_string(retval);
1409: PHP_STRLCPY(ent->d_name, Z_STRVAL_P(retval), sizeof(ent->d_name), Z_STRLEN_P(retval));
1410:
1411: didread = sizeof(php_stream_dirent);
1412: } else if (call_result == FAILURE) {
1413: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_DIR_READ " is not implemented!",
1414: us->wrapper->classname);
1415: }
1416:
1417: if (retval)
1418: zval_ptr_dtor(&retval);
1419:
1420: return didread;
1421: }
1422:
1423: static int php_userstreamop_closedir(php_stream *stream, int close_handle TSRMLS_DC)
1424: {
1425: zval func_name;
1426: zval *retval = NULL;
1427: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
1428:
1429: assert(us != NULL);
1430:
1431: ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1, 0);
1432:
1433: call_user_function_ex(NULL,
1434: &us->object,
1435: &func_name,
1436: &retval,
1437: 0, NULL, 0, NULL TSRMLS_CC);
1438:
1439: if (retval)
1440: zval_ptr_dtor(&retval);
1441:
1442: zval_ptr_dtor(&us->object);
1443:
1444: efree(us);
1445:
1446: return 0;
1447: }
1448:
1449: static int php_userstreamop_rewinddir(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
1450: {
1451: zval func_name;
1452: zval *retval = NULL;
1453: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
1454:
1455: ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1, 0);
1456:
1457: call_user_function_ex(NULL,
1458: &us->object,
1459: &func_name,
1460: &retval,
1461: 0, NULL, 0, NULL TSRMLS_CC);
1462:
1463: if (retval)
1464: zval_ptr_dtor(&retval);
1465:
1466: return 0;
1467:
1468: }
1469:
1470: static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr TSRMLS_DC)
1471: {
1472: php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
1473: zval func_name;
1474: zval *retval = NULL;
1475: zval *zcastas = NULL;
1476: zval **args[1];
1477: php_stream * intstream = NULL;
1478: int call_result;
1479: int ret = FAILURE;
1480:
1481: ZVAL_STRINGL(&func_name, USERSTREAM_CAST, sizeof(USERSTREAM_CAST)-1, 0);
1482:
1483: ALLOC_INIT_ZVAL(zcastas);
1484: switch(castas) {
1485: case PHP_STREAM_AS_FD_FOR_SELECT:
1486: ZVAL_LONG(zcastas, PHP_STREAM_AS_FD_FOR_SELECT);
1487: break;
1488: default:
1489: ZVAL_LONG(zcastas, PHP_STREAM_AS_STDIO);
1490: break;
1491: }
1492: args[0] = &zcastas;
1493:
1494: call_result = call_user_function_ex(NULL,
1495: &us->object,
1496: &func_name,
1497: &retval,
1498: 1, args, 0, NULL TSRMLS_CC);
1499:
1500: do {
1501: if (call_result == FAILURE) {
1502: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_CAST " is not implemented!",
1503: us->wrapper->classname);
1504: break;
1505: }
1506: if (retval == NULL || !zend_is_true(retval)) {
1507: break;
1508: }
1509: php_stream_from_zval_no_verify(intstream, &retval);
1510: if (!intstream) {
1511: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_CAST " must return a stream resource",
1512: us->wrapper->classname);
1513: break;
1514: }
1515: if (intstream == stream) {
1516: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_CAST " must not return itself",
1517: us->wrapper->classname);
1518: intstream = NULL;
1519: break;
1520: }
1521: ret = php_stream_cast(intstream, castas, retptr, 1);
1522: } while (0);
1523:
1524: if (retval) {
1525: zval_ptr_dtor(&retval);
1526: }
1527: if (zcastas) {
1528: zval_ptr_dtor(&zcastas);
1529: }
1530:
1531: return ret;
1532: }
1533:
1534: php_stream_ops php_stream_userspace_ops = {
1535: php_userstreamop_write, php_userstreamop_read,
1536: php_userstreamop_close, php_userstreamop_flush,
1537: "user-space",
1538: php_userstreamop_seek,
1539: php_userstreamop_cast,
1540: php_userstreamop_stat,
1541: php_userstreamop_set_option,
1542: };
1543:
1544: php_stream_ops php_stream_userspace_dir_ops = {
1545: NULL, /* write */
1546: php_userstreamop_readdir,
1547: php_userstreamop_closedir,
1548: NULL, /* flush */
1549: "user-space-dir",
1550: php_userstreamop_rewinddir,
1551: NULL, /* cast */
1552: NULL, /* stat */
1553: NULL /* set_option */
1554: };
1555:
1556:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to userspace.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