Annotation of embedaddon/php/main/streams/cast.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Wez Furlong <wez@thebrainroom.com> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: cast.c 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #define _GNU_SOURCE
! 22: #include "php.h"
! 23: #include "php_globals.h"
! 24: #include "php_network.h"
! 25: #include "php_open_temporary_file.h"
! 26: #include "ext/standard/file.h"
! 27: #include <stddef.h>
! 28: #include <fcntl.h>
! 29:
! 30: #include "php_streams_int.h"
! 31:
! 32: /* Under BSD, emulate fopencookie using funopen */
! 33: #if defined(HAVE_FUNOPEN) && !defined(HAVE_FOPENCOOKIE)
! 34: typedef struct {
! 35: int (*reader)(void *, char *, int);
! 36: int (*writer)(void *, const char *, int);
! 37: fpos_t (*seeker)(void *, fpos_t, int);
! 38: int (*closer)(void *);
! 39: } COOKIE_IO_FUNCTIONS_T;
! 40:
! 41: FILE *fopencookie(void *cookie, const char *mode, COOKIE_IO_FUNCTIONS_T *funcs)
! 42: {
! 43: return funopen(cookie, funcs->reader, funcs->writer, funcs->seeker, funcs->closer);
! 44: }
! 45: # define HAVE_FOPENCOOKIE 1
! 46: # define PHP_EMULATE_FOPENCOOKIE 1
! 47: # define PHP_STREAM_COOKIE_FUNCTIONS &stream_cookie_functions
! 48: #elif defined(HAVE_FOPENCOOKIE)
! 49: # define PHP_STREAM_COOKIE_FUNCTIONS stream_cookie_functions
! 50: #endif
! 51:
! 52: /* {{{ STDIO with fopencookie */
! 53: #if defined(PHP_EMULATE_FOPENCOOKIE)
! 54: /* use our fopencookie emulation */
! 55: static int stream_cookie_reader(void *cookie, char *buffer, int size)
! 56: {
! 57: int ret;
! 58: TSRMLS_FETCH();
! 59:
! 60: ret = php_stream_read((php_stream*)cookie, buffer, size);
! 61: return ret;
! 62: }
! 63:
! 64: static int stream_cookie_writer(void *cookie, const char *buffer, int size)
! 65: {
! 66: TSRMLS_FETCH();
! 67:
! 68: return php_stream_write((php_stream *)cookie, (char *)buffer, size);
! 69: }
! 70:
! 71: static fpos_t stream_cookie_seeker(void *cookie, off_t position, int whence)
! 72: {
! 73: TSRMLS_FETCH();
! 74:
! 75: return (fpos_t)php_stream_seek((php_stream *)cookie, position, whence);
! 76: }
! 77:
! 78: static int stream_cookie_closer(void *cookie)
! 79: {
! 80: php_stream *stream = (php_stream*)cookie;
! 81: TSRMLS_FETCH();
! 82:
! 83: /* prevent recursion */
! 84: stream->fclose_stdiocast = PHP_STREAM_FCLOSE_NONE;
! 85: return php_stream_close(stream);
! 86: }
! 87: #elif defined(HAVE_FOPENCOOKIE)
! 88: static ssize_t stream_cookie_reader(void *cookie, char *buffer, size_t size)
! 89: {
! 90: ssize_t ret;
! 91: TSRMLS_FETCH();
! 92:
! 93: ret = php_stream_read(((php_stream *)cookie), buffer, size);
! 94: return ret;
! 95: }
! 96:
! 97: static ssize_t stream_cookie_writer(void *cookie, const char *buffer, size_t size)
! 98: {
! 99: TSRMLS_FETCH();
! 100:
! 101: return php_stream_write(((php_stream *)cookie), (char *)buffer, size);
! 102: }
! 103:
! 104: # ifdef COOKIE_SEEKER_USES_OFF64_T
! 105: static int stream_cookie_seeker(void *cookie, __off64_t *position, int whence)
! 106: {
! 107: TSRMLS_FETCH();
! 108:
! 109: *position = php_stream_seek((php_stream *)cookie, (off_t)*position, whence);
! 110:
! 111: if (*position == -1) {
! 112: return -1;
! 113: }
! 114: return 0;
! 115: }
! 116: # else
! 117: static int stream_cookie_seeker(void *cookie, off_t position, int whence)
! 118: {
! 119: TSRMLS_FETCH();
! 120:
! 121: return php_stream_seek((php_stream *)cookie, position, whence);
! 122: }
! 123: # endif
! 124:
! 125: static int stream_cookie_closer(void *cookie)
! 126: {
! 127: php_stream *stream = (php_stream*)cookie;
! 128: TSRMLS_FETCH();
! 129:
! 130: /* prevent recursion */
! 131: stream->fclose_stdiocast = PHP_STREAM_FCLOSE_NONE;
! 132: return php_stream_close(stream);
! 133: }
! 134: #endif /* elif defined(HAVE_FOPENCOOKIE) */
! 135:
! 136: #if HAVE_FOPENCOOKIE
! 137: static COOKIE_IO_FUNCTIONS_T stream_cookie_functions =
! 138: {
! 139: stream_cookie_reader, stream_cookie_writer,
! 140: stream_cookie_seeker, stream_cookie_closer
! 141: };
! 142: #else
! 143: /* TODO: use socketpair() to emulate fopencookie, as suggested by Hartmut ? */
! 144: #endif
! 145: /* }}} */
! 146:
! 147: /* {{{ php_stream_mode_sanitize_fdopen_fopencookie
! 148: * Result should have at least size 5, e.g. to write wbx+\0 */
! 149: void php_stream_mode_sanitize_fdopen_fopencookie(php_stream *stream, char *result)
! 150: {
! 151: /* replace modes not supported by fdopen and fopencookie, but supported
! 152: * by PHP's fread(), so that their calls won't fail */
! 153: const char *cur_mode = stream->mode;
! 154: int has_plus = 0,
! 155: has_bin = 0,
! 156: i,
! 157: res_curs = 0;
! 158:
! 159: if (cur_mode[0] == 'r' || cur_mode[0] == 'w' || cur_mode[0] == 'a') {
! 160: result[res_curs++] = cur_mode[0];
! 161: } else {
! 162: /* assume cur_mode[0] is 'c' or 'x'; substitute by 'w', which should not
! 163: * truncate anything in fdopen/fopencookie */
! 164: result[res_curs++] = 'w';
! 165:
! 166: /* x is allowed (at least by glibc & compat), but not as the 1st mode
! 167: * as in PHP and in any case is (at best) ignored by fdopen and fopencookie */
! 168: }
! 169:
! 170: /* assume current mode has at most length 4 (e.g. wbn+) */
! 171: for (i = 1; i < 4 && cur_mode[i] != '\0'; i++) {
! 172: if (cur_mode[i] == 'b') {
! 173: has_bin = 1;
! 174: } else if (cur_mode[i] == '+') {
! 175: has_plus = 1;
! 176: }
! 177: /* ignore 'n', 't' or other stuff */
! 178: }
! 179:
! 180: if (has_bin) {
! 181: result[res_curs++] = 'b';
! 182: }
! 183: if (has_plus) {
! 184: result[res_curs++] = '+';
! 185: }
! 186:
! 187: result[res_curs] = '\0';
! 188: }
! 189: /* }}} */
! 190:
! 191: /* {{{ php_stream_cast */
! 192: PHPAPI int _php_stream_cast(php_stream *stream, int castas, void **ret, int show_err TSRMLS_DC)
! 193: {
! 194: int flags = castas & PHP_STREAM_CAST_MASK;
! 195: castas &= ~PHP_STREAM_CAST_MASK;
! 196:
! 197: /* synchronize our buffer (if possible) */
! 198: if (ret && castas != PHP_STREAM_AS_FD_FOR_SELECT) {
! 199: php_stream_flush(stream);
! 200: if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
! 201: off_t dummy;
! 202:
! 203: stream->ops->seek(stream, stream->position, SEEK_SET, &dummy TSRMLS_CC);
! 204: stream->readpos = stream->writepos = 0;
! 205: }
! 206: }
! 207:
! 208: /* filtered streams can only be cast as stdio, and only when fopencookie is present */
! 209:
! 210: if (castas == PHP_STREAM_AS_STDIO) {
! 211: if (stream->stdiocast) {
! 212: if (ret) {
! 213: *(FILE**)ret = stream->stdiocast;
! 214: }
! 215: goto exit_success;
! 216: }
! 217:
! 218: /* if the stream is a stdio stream let's give it a chance to respond
! 219: * first, to avoid doubling up the layers of stdio with an fopencookie */
! 220: if (php_stream_is(stream, PHP_STREAM_IS_STDIO) &&
! 221: stream->ops->cast &&
! 222: !php_stream_is_filtered(stream) &&
! 223: stream->ops->cast(stream, castas, ret TSRMLS_CC) == SUCCESS
! 224: ) {
! 225: goto exit_success;
! 226: }
! 227:
! 228: #if HAVE_FOPENCOOKIE
! 229: /* if just checking, say yes we can be a FILE*, but don't actually create it yet */
! 230: if (ret == NULL) {
! 231: goto exit_success;
! 232: }
! 233:
! 234: {
! 235: char fixed_mode[5];
! 236: php_stream_mode_sanitize_fdopen_fopencookie(stream, fixed_mode);
! 237: *(FILE**)ret = fopencookie(stream, fixed_mode, PHP_STREAM_COOKIE_FUNCTIONS);
! 238: }
! 239:
! 240: if (*ret != NULL) {
! 241: off_t pos;
! 242:
! 243: stream->fclose_stdiocast = PHP_STREAM_FCLOSE_FOPENCOOKIE;
! 244:
! 245: /* If the stream position is not at the start, we need to force
! 246: * the stdio layer to believe it's real location. */
! 247: pos = php_stream_tell(stream);
! 248: if (pos > 0) {
! 249: fseek(*ret, pos, SEEK_SET);
! 250: }
! 251:
! 252: goto exit_success;
! 253: }
! 254:
! 255: /* must be either:
! 256: a) programmer error
! 257: b) no memory
! 258: -> lets bail
! 259: */
! 260: php_error_docref(NULL TSRMLS_CC, E_ERROR, "fopencookie failed");
! 261: return FAILURE;
! 262: #endif
! 263:
! 264: if (!php_stream_is_filtered(stream) && stream->ops->cast && stream->ops->cast(stream, castas, NULL TSRMLS_CC) == SUCCESS) {
! 265: if (FAILURE == stream->ops->cast(stream, castas, ret TSRMLS_CC)) {
! 266: return FAILURE;
! 267: }
! 268: goto exit_success;
! 269: } else if (flags & PHP_STREAM_CAST_TRY_HARD) {
! 270: php_stream *newstream;
! 271:
! 272: newstream = php_stream_fopen_tmpfile();
! 273: if (newstream) {
! 274: size_t retcopy = php_stream_copy_to_stream_ex(stream, newstream, PHP_STREAM_COPY_ALL, NULL);
! 275:
! 276: if (retcopy != SUCCESS) {
! 277: php_stream_close(newstream);
! 278: } else {
! 279: int retcast = php_stream_cast(newstream, castas | flags, (void **)ret, show_err);
! 280:
! 281: if (retcast == SUCCESS) {
! 282: rewind(*(FILE**)ret);
! 283: }
! 284:
! 285: /* do some specialized cleanup */
! 286: if ((flags & PHP_STREAM_CAST_RELEASE)) {
! 287: php_stream_free(stream, PHP_STREAM_FREE_CLOSE_CASTED);
! 288: }
! 289:
! 290: /* TODO: we probably should be setting .stdiocast and .fclose_stdiocast or
! 291: * we may be leaking the FILE*. Needs investigation, though. */
! 292: return retcast;
! 293: }
! 294: }
! 295: }
! 296: }
! 297:
! 298: if (php_stream_is_filtered(stream)) {
! 299: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot cast a filtered stream on this system");
! 300: return FAILURE;
! 301: } else if (stream->ops->cast && stream->ops->cast(stream, castas, ret TSRMLS_CC) == SUCCESS) {
! 302: goto exit_success;
! 303: }
! 304:
! 305: if (show_err) {
! 306: /* these names depend on the values of the PHP_STREAM_AS_XXX defines in php_streams.h */
! 307: static const char *cast_names[4] = {
! 308: "STDIO FILE*",
! 309: "File Descriptor",
! 310: "Socket Descriptor",
! 311: "select()able descriptor"
! 312: };
! 313:
! 314: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot represent a stream of type %s as a %s", stream->ops->label, cast_names[castas]);
! 315: }
! 316:
! 317: return FAILURE;
! 318:
! 319: exit_success:
! 320:
! 321: if ((stream->writepos - stream->readpos) > 0 &&
! 322: stream->fclose_stdiocast != PHP_STREAM_FCLOSE_FOPENCOOKIE &&
! 323: (flags & PHP_STREAM_CAST_INTERNAL) == 0
! 324: ) {
! 325: /* the data we have buffered will be lost to the third party library that
! 326: * will be accessing the stream. Emit a warning so that the end-user will
! 327: * know that they should try something else */
! 328:
! 329: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld bytes of buffered data lost during stream conversion!", (long)(stream->writepos - stream->readpos));
! 330: }
! 331:
! 332: if (castas == PHP_STREAM_AS_STDIO && ret) {
! 333: stream->stdiocast = *(FILE**)ret;
! 334: }
! 335:
! 336: if (flags & PHP_STREAM_CAST_RELEASE) {
! 337: php_stream_free(stream, PHP_STREAM_FREE_CLOSE_CASTED);
! 338: }
! 339:
! 340: return SUCCESS;
! 341:
! 342: }
! 343: /* }}} */
! 344:
! 345: /* {{{ php_stream_open_wrapper_as_file */
! 346: PHPAPI FILE * _php_stream_open_wrapper_as_file(char *path, char *mode, int options, char **opened_path STREAMS_DC TSRMLS_DC)
! 347: {
! 348: FILE *fp = NULL;
! 349: php_stream *stream = NULL;
! 350:
! 351: stream = php_stream_open_wrapper_rel(path, mode, options|STREAM_WILL_CAST, opened_path);
! 352:
! 353: if (stream == NULL) {
! 354: return NULL;
! 355: }
! 356:
! 357: if (php_stream_cast(stream, PHP_STREAM_AS_STDIO|PHP_STREAM_CAST_TRY_HARD|PHP_STREAM_CAST_RELEASE, (void**)&fp, REPORT_ERRORS) == FAILURE) {
! 358: php_stream_close(stream);
! 359: if (opened_path && *opened_path) {
! 360: efree(*opened_path);
! 361: }
! 362: return NULL;
! 363: }
! 364: return fp;
! 365: }
! 366: /* }}} */
! 367:
! 368: /* {{{ php_stream_make_seekable */
! 369: PHPAPI int _php_stream_make_seekable(php_stream *origstream, php_stream **newstream, int flags STREAMS_DC TSRMLS_DC)
! 370: {
! 371: if (newstream == NULL) {
! 372: return PHP_STREAM_FAILED;
! 373: }
! 374: *newstream = NULL;
! 375:
! 376: if (((flags & PHP_STREAM_FORCE_CONVERSION) == 0) && origstream->ops->seek != NULL) {
! 377: *newstream = origstream;
! 378: return PHP_STREAM_UNCHANGED;
! 379: }
! 380:
! 381: /* Use a tmpfile and copy the old streams contents into it */
! 382:
! 383: if (flags & PHP_STREAM_PREFER_STDIO) {
! 384: *newstream = php_stream_fopen_tmpfile();
! 385: } else {
! 386: *newstream = php_stream_temp_new();
! 387: }
! 388:
! 389: if (*newstream == NULL) {
! 390: return PHP_STREAM_FAILED;
! 391: }
! 392:
! 393: #if ZEND_DEBUG
! 394: (*newstream)->open_filename = origstream->open_filename;
! 395: (*newstream)->open_lineno = origstream->open_lineno;
! 396: #endif
! 397:
! 398: if (php_stream_copy_to_stream_ex(origstream, *newstream, PHP_STREAM_COPY_ALL, NULL) != SUCCESS) {
! 399: php_stream_close(*newstream);
! 400: *newstream = NULL;
! 401: return PHP_STREAM_CRITICAL;
! 402: }
! 403:
! 404: php_stream_close(origstream);
! 405: php_stream_seek(*newstream, 0, SEEK_SET);
! 406:
! 407: return PHP_STREAM_RELEASED;
! 408: }
! 409: /* }}} */
! 410:
! 411: /*
! 412: * Local variables:
! 413: * tab-width: 4
! 414: * c-basic-offset: 4
! 415: * End:
! 416: * vim600: noet sw=4 ts=4 fdm=marker
! 417: * vim<600: noet sw=4 ts=4
! 418: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cast.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