Annotation of embedaddon/php/ext/standard/streamsfuncs.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: | Sara Golemon <pollita@php.net> |
! 17: +----------------------------------------------------------------------+
! 18: */
! 19:
! 20: /* $Id: streamsfuncs.c 321634 2012-01-01 13:15:04Z felipe $ */
! 21:
! 22: #include "php.h"
! 23: #include "php_globals.h"
! 24: #include "ext/standard/flock_compat.h"
! 25: #include "ext/standard/file.h"
! 26: #include "ext/standard/php_filestat.h"
! 27: #include "php_open_temporary_file.h"
! 28: #include "ext/standard/basic_functions.h"
! 29: #include "php_ini.h"
! 30: #include "streamsfuncs.h"
! 31: #include "php_network.h"
! 32: #include "php_string.h"
! 33:
! 34: #ifndef PHP_WIN32
! 35: #define php_select(m, r, w, e, t) select(m, r, w, e, t)
! 36: typedef unsigned long long php_timeout_ull;
! 37: #else
! 38: #include "win32/select.h"
! 39: #include "win32/sockets.h"
! 40: typedef unsigned __int64 php_timeout_ull;
! 41: #endif
! 42:
! 43: static php_stream_context *decode_context_param(zval *contextresource TSRMLS_DC);
! 44:
! 45: /* Streams based network functions */
! 46:
! 47: #if HAVE_SOCKETPAIR
! 48: /* {{{ proto array stream_socket_pair(int domain, int type, int protocol)
! 49: Creates a pair of connected, indistinguishable socket streams */
! 50: PHP_FUNCTION(stream_socket_pair)
! 51: {
! 52: long domain, type, protocol;
! 53: php_stream *s1, *s2;
! 54: int pair[2];
! 55:
! 56: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
! 57: &domain, &type, &protocol)) {
! 58: RETURN_FALSE;
! 59: }
! 60:
! 61: if (0 != socketpair(domain, type, protocol, pair)) {
! 62: char errbuf[256];
! 63: php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to create sockets: [%d]: %s",
! 64: php_socket_errno(), php_socket_strerror(php_socket_errno(), errbuf, sizeof(errbuf)));
! 65: RETURN_FALSE;
! 66: }
! 67:
! 68: array_init(return_value);
! 69:
! 70: s1 = php_stream_sock_open_from_socket(pair[0], 0);
! 71: s2 = php_stream_sock_open_from_socket(pair[1], 0);
! 72:
! 73: /* set the __exposed flag.
! 74: * php_stream_to_zval() does, add_next_index_resource() does not */
! 75: php_stream_auto_cleanup(s1);
! 76: php_stream_auto_cleanup(s2);
! 77:
! 78: add_next_index_resource(return_value, php_stream_get_resource_id(s1));
! 79: add_next_index_resource(return_value, php_stream_get_resource_id(s2));
! 80: }
! 81: /* }}} */
! 82: #endif
! 83:
! 84: /* {{{ proto resource stream_socket_client(string remoteaddress [, long &errcode [, string &errstring [, double timeout [, long flags [, resource context]]]]])
! 85: Open a client connection to a remote address */
! 86: PHP_FUNCTION(stream_socket_client)
! 87: {
! 88: char *host;
! 89: int host_len;
! 90: zval *zerrno = NULL, *zerrstr = NULL, *zcontext = NULL;
! 91: double timeout = FG(default_socket_timeout);
! 92: php_timeout_ull conv;
! 93: struct timeval tv;
! 94: char *hashkey = NULL;
! 95: php_stream *stream = NULL;
! 96: int err;
! 97: long flags = PHP_STREAM_CLIENT_CONNECT;
! 98: char *errstr = NULL;
! 99: php_stream_context *context = NULL;
! 100:
! 101: RETVAL_FALSE;
! 102:
! 103: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|zzdlr", &host, &host_len, &zerrno, &zerrstr, &timeout, &flags, &zcontext) == FAILURE) {
! 104: RETURN_FALSE;
! 105: }
! 106:
! 107: context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);
! 108:
! 109: if (context) {
! 110: zend_list_addref(context->rsrc_id);
! 111: }
! 112:
! 113: if (flags & PHP_STREAM_CLIENT_PERSISTENT) {
! 114: spprintf(&hashkey, 0, "stream_socket_client__%s", host);
! 115: }
! 116:
! 117: /* prepare the timeout value for use */
! 118: conv = (php_timeout_ull) (timeout * 1000000.0);
! 119: #ifdef PHP_WIN32
! 120: tv.tv_sec = (long)(conv / 1000000);
! 121: tv.tv_usec =(long)(conv % 1000000);
! 122: #else
! 123: tv.tv_sec = conv / 1000000;
! 124: tv.tv_usec = conv % 1000000;
! 125: #endif
! 126: if (zerrno) {
! 127: zval_dtor(zerrno);
! 128: ZVAL_LONG(zerrno, 0);
! 129: }
! 130: if (zerrstr) {
! 131: zval_dtor(zerrstr);
! 132: ZVAL_STRING(zerrstr, "", 1);
! 133: }
! 134:
! 135: stream = php_stream_xport_create(host, host_len, ENFORCE_SAFE_MODE | REPORT_ERRORS,
! 136: STREAM_XPORT_CLIENT | (flags & PHP_STREAM_CLIENT_CONNECT ? STREAM_XPORT_CONNECT : 0) |
! 137: (flags & PHP_STREAM_CLIENT_ASYNC_CONNECT ? STREAM_XPORT_CONNECT_ASYNC : 0),
! 138: hashkey, &tv, context, &errstr, &err);
! 139:
! 140:
! 141: if (stream == NULL) {
! 142: /* host might contain binary characters */
! 143: char *quoted_host = php_addslashes(host, host_len, NULL, 0 TSRMLS_CC);
! 144:
! 145: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to connect to %s (%s)", quoted_host, errstr == NULL ? "Unknown error" : errstr);
! 146: efree(quoted_host);
! 147: }
! 148:
! 149: if (hashkey) {
! 150: efree(hashkey);
! 151: }
! 152:
! 153: if (stream == NULL) {
! 154: if (zerrno) {
! 155: zval_dtor(zerrno);
! 156: ZVAL_LONG(zerrno, err);
! 157: }
! 158: if (zerrstr && errstr) {
! 159: /* no need to dup; we need to efree buf anyway */
! 160: zval_dtor(zerrstr);
! 161: ZVAL_STRING(zerrstr, errstr, 0);
! 162: } else if (errstr) {
! 163: efree(errstr);
! 164: }
! 165: RETURN_FALSE;
! 166: }
! 167:
! 168: if (errstr) {
! 169: efree(errstr);
! 170: }
! 171:
! 172: php_stream_to_zval(stream, return_value);
! 173:
! 174: }
! 175: /* }}} */
! 176:
! 177: /* {{{ proto resource stream_socket_server(string localaddress [, long &errcode [, string &errstring [, long flags [, resource context]]]])
! 178: Create a server socket bound to localaddress */
! 179: PHP_FUNCTION(stream_socket_server)
! 180: {
! 181: char *host;
! 182: int host_len;
! 183: zval *zerrno = NULL, *zerrstr = NULL, *zcontext = NULL;
! 184: php_stream *stream = NULL;
! 185: int err = 0;
! 186: long flags = STREAM_XPORT_BIND | STREAM_XPORT_LISTEN;
! 187: char *errstr = NULL;
! 188: php_stream_context *context = NULL;
! 189:
! 190: RETVAL_FALSE;
! 191:
! 192: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|zzlr", &host, &host_len, &zerrno, &zerrstr, &flags, &zcontext) == FAILURE) {
! 193: RETURN_FALSE;
! 194: }
! 195:
! 196: context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);
! 197:
! 198: if (context) {
! 199: zend_list_addref(context->rsrc_id);
! 200: }
! 201:
! 202: if (zerrno) {
! 203: zval_dtor(zerrno);
! 204: ZVAL_LONG(zerrno, 0);
! 205: }
! 206: if (zerrstr) {
! 207: zval_dtor(zerrstr);
! 208: ZVAL_STRING(zerrstr, "", 1);
! 209: }
! 210:
! 211: stream = php_stream_xport_create(host, host_len, ENFORCE_SAFE_MODE | REPORT_ERRORS,
! 212: STREAM_XPORT_SERVER | flags,
! 213: NULL, NULL, context, &errstr, &err);
! 214:
! 215: if (stream == NULL) {
! 216: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to connect to %s (%s)", host, errstr == NULL ? "Unknown error" : errstr);
! 217: }
! 218:
! 219: if (stream == NULL) {
! 220: if (zerrno) {
! 221: zval_dtor(zerrno);
! 222: ZVAL_LONG(zerrno, err);
! 223: }
! 224: if (zerrstr && errstr) {
! 225: /* no need to dup; we need to efree buf anyway */
! 226: zval_dtor(zerrstr);
! 227: ZVAL_STRING(zerrstr, errstr, 0);
! 228: } else if (errstr) {
! 229: efree(errstr);
! 230: }
! 231: RETURN_FALSE;
! 232: }
! 233:
! 234: if (errstr) {
! 235: efree(errstr);
! 236: }
! 237:
! 238: php_stream_to_zval(stream, return_value);
! 239: }
! 240: /* }}} */
! 241:
! 242: /* {{{ proto resource stream_socket_accept(resource serverstream, [ double timeout [, string &peername ]])
! 243: Accept a client connection from a server socket */
! 244: PHP_FUNCTION(stream_socket_accept)
! 245: {
! 246: double timeout = FG(default_socket_timeout);
! 247: zval *zpeername = NULL;
! 248: char *peername = NULL;
! 249: int peername_len;
! 250: php_timeout_ull conv;
! 251: struct timeval tv;
! 252: php_stream *stream = NULL, *clistream = NULL;
! 253: zval *zstream;
! 254:
! 255: char *errstr = NULL;
! 256:
! 257: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|dz", &zstream, &timeout, &zpeername) == FAILURE) {
! 258: RETURN_FALSE;
! 259: }
! 260:
! 261: php_stream_from_zval(stream, &zstream);
! 262:
! 263: /* prepare the timeout value for use */
! 264: conv = (php_timeout_ull) (timeout * 1000000.0);
! 265: #ifdef PHP_WIN32
! 266: tv.tv_sec = (long)(conv / 1000000);
! 267: tv.tv_usec = (long)(conv % 1000000);
! 268: #else
! 269: tv.tv_sec = conv / 1000000;
! 270: tv.tv_usec = conv % 1000000;
! 271: #endif
! 272: if (zpeername) {
! 273: zval_dtor(zpeername);
! 274: ZVAL_NULL(zpeername);
! 275: }
! 276:
! 277: if (0 == php_stream_xport_accept(stream, &clistream,
! 278: zpeername ? &peername : NULL,
! 279: zpeername ? &peername_len : NULL,
! 280: NULL, NULL,
! 281: &tv, &errstr
! 282: TSRMLS_CC) && clistream) {
! 283:
! 284: if (peername) {
! 285: ZVAL_STRINGL(zpeername, peername, peername_len, 0);
! 286: }
! 287: php_stream_to_zval(clistream, return_value);
! 288: } else {
! 289: php_error_docref(NULL TSRMLS_CC, E_WARNING, "accept failed: %s", errstr ? errstr : "Unknown error");
! 290: RETVAL_FALSE;
! 291: }
! 292:
! 293: if (errstr) {
! 294: efree(errstr);
! 295: }
! 296: }
! 297: /* }}} */
! 298:
! 299: /* {{{ proto string stream_socket_get_name(resource stream, bool want_peer)
! 300: Returns either the locally bound or remote name for a socket stream */
! 301: PHP_FUNCTION(stream_socket_get_name)
! 302: {
! 303: php_stream *stream;
! 304: zval *zstream;
! 305: zend_bool want_peer;
! 306: char *name = NULL;
! 307: int name_len;
! 308:
! 309: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb", &zstream, &want_peer) == FAILURE) {
! 310: RETURN_FALSE;
! 311: }
! 312:
! 313: php_stream_from_zval(stream, &zstream);
! 314:
! 315: if (0 != php_stream_xport_get_name(stream, want_peer,
! 316: &name,
! 317: &name_len,
! 318: NULL, NULL
! 319: TSRMLS_CC)) {
! 320: RETURN_FALSE;
! 321: }
! 322:
! 323: RETURN_STRINGL(name, name_len, 0);
! 324: }
! 325: /* }}} */
! 326:
! 327: /* {{{ proto long stream_socket_sendto(resouce stream, string data [, long flags [, string target_addr]])
! 328: Send data to a socket stream. If target_addr is specified it must be in dotted quad (or [ipv6]) format */
! 329: PHP_FUNCTION(stream_socket_sendto)
! 330: {
! 331: php_stream *stream;
! 332: zval *zstream;
! 333: long flags = 0;
! 334: char *data, *target_addr = NULL;
! 335: int datalen, target_addr_len = 0;
! 336: php_sockaddr_storage sa;
! 337: socklen_t sl = 0;
! 338:
! 339: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|ls", &zstream, &data, &datalen, &flags, &target_addr, &target_addr_len) == FAILURE) {
! 340: RETURN_FALSE;
! 341: }
! 342: php_stream_from_zval(stream, &zstream);
! 343:
! 344: if (target_addr_len) {
! 345: /* parse the address */
! 346: if (FAILURE == php_network_parse_network_address_with_port(target_addr, target_addr_len, (struct sockaddr*)&sa, &sl TSRMLS_CC)) {
! 347: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to parse `%s' into a valid network address", target_addr);
! 348: RETURN_FALSE;
! 349: }
! 350: }
! 351:
! 352: RETURN_LONG(php_stream_xport_sendto(stream, data, datalen, flags, target_addr ? &sa : NULL, sl TSRMLS_CC));
! 353: }
! 354: /* }}} */
! 355:
! 356: /* {{{ proto string stream_socket_recvfrom(resource stream, long amount [, long flags [, string &remote_addr]])
! 357: Receives data from a socket stream */
! 358: PHP_FUNCTION(stream_socket_recvfrom)
! 359: {
! 360: php_stream *stream;
! 361: zval *zstream, *zremote = NULL;
! 362: char *remote_addr = NULL;
! 363: int remote_addr_len;
! 364: long to_read = 0;
! 365: char *read_buf;
! 366: long flags = 0;
! 367: int recvd;
! 368:
! 369: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|lz", &zstream, &to_read, &flags, &zremote) == FAILURE) {
! 370: RETURN_FALSE;
! 371: }
! 372:
! 373: php_stream_from_zval(stream, &zstream);
! 374:
! 375: if (zremote) {
! 376: zval_dtor(zremote);
! 377: ZVAL_NULL(zremote);
! 378: }
! 379:
! 380: if (to_read <= 0) {
! 381: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length parameter must be greater than 0");
! 382: RETURN_FALSE;
! 383: }
! 384:
! 385: read_buf = safe_emalloc(1, to_read, 1);
! 386:
! 387: recvd = php_stream_xport_recvfrom(stream, read_buf, to_read, flags, NULL, NULL,
! 388: zremote ? &remote_addr : NULL,
! 389: zremote ? &remote_addr_len : NULL
! 390: TSRMLS_CC);
! 391:
! 392: if (recvd >= 0) {
! 393: if (zremote) {
! 394: ZVAL_STRINGL(zremote, remote_addr, remote_addr_len, 0);
! 395: }
! 396: read_buf[recvd] = '\0';
! 397:
! 398: if (PG(magic_quotes_runtime)) {
! 399: Z_TYPE_P(return_value) = IS_STRING;
! 400: Z_STRVAL_P(return_value) = php_addslashes(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), &Z_STRLEN_P(return_value), 1 TSRMLS_CC);
! 401: return;
! 402: } else {
! 403: RETURN_STRINGL(read_buf, recvd, 0);
! 404: }
! 405: }
! 406:
! 407: efree(read_buf);
! 408: RETURN_FALSE;
! 409: }
! 410: /* }}} */
! 411:
! 412: /* {{{ proto string stream_get_contents(resource source [, long maxlen [, long offset]])
! 413: Reads all remaining bytes (or up to maxlen bytes) from a stream and returns them as a string. */
! 414: PHP_FUNCTION(stream_get_contents)
! 415: {
! 416: php_stream *stream;
! 417: zval *zsrc;
! 418: long maxlen = PHP_STREAM_COPY_ALL,
! 419: desiredpos = -1L;
! 420: int len,
! 421: newlen;
! 422: char *contents = NULL;
! 423:
! 424: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &zsrc, &maxlen, &desiredpos) == FAILURE) {
! 425: RETURN_FALSE;
! 426: }
! 427:
! 428: php_stream_from_zval(stream, &zsrc);
! 429:
! 430: if (desiredpos >= 0) {
! 431: int seek_res = 0;
! 432: off_t position;
! 433:
! 434: position = php_stream_tell(stream);
! 435: if (position >= 0 && desiredpos > position) {
! 436: /* use SEEK_CUR to allow emulation in streams that don't support seeking */
! 437: seek_res = php_stream_seek(stream, desiredpos - position, SEEK_CUR);
! 438: } else if (desiredpos < position) {
! 439: /* desired position before position or error on tell */
! 440: seek_res = php_stream_seek(stream, desiredpos, SEEK_SET);
! 441: }
! 442:
! 443: if (seek_res != 0) {
! 444: php_error_docref(NULL TSRMLS_CC, E_WARNING,
! 445: "Failed to seek to position %ld in the stream", desiredpos);
! 446: RETURN_FALSE;
! 447: }
! 448: }
! 449:
! 450: len = php_stream_copy_to_mem(stream, &contents, maxlen, 0);
! 451:
! 452: if (contents) {
! 453: if (len && PG(magic_quotes_runtime)) {
! 454: contents = php_addslashes(contents, len, &newlen, 1 TSRMLS_CC); /* 1 = free source string */
! 455: len = newlen;
! 456: }
! 457: RETVAL_STRINGL(contents, len, 0);
! 458: } else {
! 459: RETVAL_EMPTY_STRING();
! 460: }
! 461: }
! 462: /* }}} */
! 463:
! 464: /* {{{ proto long stream_copy_to_stream(resource source, resource dest [, long maxlen [, long pos]])
! 465: Reads up to maxlen bytes from source stream and writes them to dest stream. */
! 466: PHP_FUNCTION(stream_copy_to_stream)
! 467: {
! 468: php_stream *src, *dest;
! 469: zval *zsrc, *zdest;
! 470: long maxlen = PHP_STREAM_COPY_ALL, pos = 0;
! 471: size_t len;
! 472: int ret;
! 473:
! 474: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|ll", &zsrc, &zdest, &maxlen, &pos) == FAILURE) {
! 475: RETURN_FALSE;
! 476: }
! 477:
! 478: php_stream_from_zval(src, &zsrc);
! 479: php_stream_from_zval(dest, &zdest);
! 480:
! 481: if (pos > 0 && php_stream_seek(src, pos, SEEK_SET) < 0) {
! 482: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to seek to position %ld in the stream", pos);
! 483: RETURN_FALSE;
! 484: }
! 485:
! 486: ret = php_stream_copy_to_stream_ex(src, dest, maxlen, &len);
! 487:
! 488: if (ret != SUCCESS) {
! 489: RETURN_FALSE;
! 490: }
! 491: RETURN_LONG(len);
! 492: }
! 493: /* }}} */
! 494:
! 495: /* {{{ proto array stream_get_meta_data(resource fp)
! 496: Retrieves header/meta data from streams/file pointers */
! 497: PHP_FUNCTION(stream_get_meta_data)
! 498: {
! 499: zval *arg1;
! 500: php_stream *stream;
! 501: zval *newval;
! 502:
! 503: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
! 504: return;
! 505: }
! 506: php_stream_from_zval(stream, &arg1);
! 507:
! 508: array_init(return_value);
! 509:
! 510: if (stream->wrapperdata) {
! 511: MAKE_STD_ZVAL(newval);
! 512: MAKE_COPY_ZVAL(&stream->wrapperdata, newval);
! 513:
! 514: add_assoc_zval(return_value, "wrapper_data", newval);
! 515: }
! 516: if (stream->wrapper) {
! 517: add_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label, 1);
! 518: }
! 519: add_assoc_string(return_value, "stream_type", (char *)stream->ops->label, 1);
! 520:
! 521: add_assoc_string(return_value, "mode", stream->mode, 1);
! 522:
! 523: #if 0 /* TODO: needs updating for new filter API */
! 524: if (stream->filterhead) {
! 525: php_stream_filter *filter;
! 526:
! 527: MAKE_STD_ZVAL(newval);
! 528: array_init(newval);
! 529:
! 530: for (filter = stream->filterhead; filter != NULL; filter = filter->next) {
! 531: add_next_index_string(newval, (char *)filter->fops->label, 1);
! 532: }
! 533:
! 534: add_assoc_zval(return_value, "filters", newval);
! 535: }
! 536: #endif
! 537:
! 538: add_assoc_long(return_value, "unread_bytes", stream->writepos - stream->readpos);
! 539:
! 540: add_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0);
! 541: if (stream->orig_path) {
! 542: add_assoc_string(return_value, "uri", stream->orig_path, 1);
! 543: }
! 544:
! 545: if (!php_stream_populate_meta_data(stream, return_value)) {
! 546: add_assoc_bool(return_value, "timed_out", 0);
! 547: add_assoc_bool(return_value, "blocked", 1);
! 548: add_assoc_bool(return_value, "eof", php_stream_eof(stream));
! 549: }
! 550:
! 551: }
! 552: /* }}} */
! 553:
! 554: /* {{{ proto array stream_get_transports()
! 555: Retrieves list of registered socket transports */
! 556: PHP_FUNCTION(stream_get_transports)
! 557: {
! 558: HashTable *stream_xport_hash;
! 559: char *stream_xport;
! 560: int stream_xport_len;
! 561: ulong num_key;
! 562:
! 563: if (zend_parse_parameters_none() == FAILURE) {
! 564: return;
! 565: }
! 566:
! 567: if ((stream_xport_hash = php_stream_xport_get_hash())) {
! 568: HashPosition pos;
! 569: array_init(return_value);
! 570: zend_hash_internal_pointer_reset_ex(stream_xport_hash, &pos);
! 571: while (zend_hash_get_current_key_ex(stream_xport_hash,
! 572: &stream_xport, &stream_xport_len,
! 573: &num_key, 0, &pos) == HASH_KEY_IS_STRING) {
! 574: add_next_index_stringl(return_value, stream_xport, stream_xport_len - 1, 1);
! 575: zend_hash_move_forward_ex(stream_xport_hash, &pos);
! 576: }
! 577: } else {
! 578: RETURN_FALSE;
! 579: }
! 580: }
! 581: /* }}} */
! 582:
! 583: /* {{{ proto array stream_get_wrappers()
! 584: Retrieves list of registered stream wrappers */
! 585: PHP_FUNCTION(stream_get_wrappers)
! 586: {
! 587: HashTable *url_stream_wrappers_hash;
! 588: char *stream_protocol;
! 589: int key_flags, stream_protocol_len = 0;
! 590: ulong num_key;
! 591:
! 592: if (zend_parse_parameters_none() == FAILURE) {
! 593: return;
! 594: }
! 595:
! 596: if ((url_stream_wrappers_hash = php_stream_get_url_stream_wrappers_hash())) {
! 597: HashPosition pos;
! 598: array_init(return_value);
! 599: for (zend_hash_internal_pointer_reset_ex(url_stream_wrappers_hash, &pos);
! 600: (key_flags = zend_hash_get_current_key_ex(url_stream_wrappers_hash, &stream_protocol, &stream_protocol_len, &num_key, 0, &pos)) != HASH_KEY_NON_EXISTANT;
! 601: zend_hash_move_forward_ex(url_stream_wrappers_hash, &pos)) {
! 602: if (key_flags == HASH_KEY_IS_STRING) {
! 603: add_next_index_stringl(return_value, stream_protocol, stream_protocol_len - 1, 1);
! 604: }
! 605: }
! 606: } else {
! 607: RETURN_FALSE;
! 608: }
! 609:
! 610: }
! 611: /* }}} */
! 612:
! 613: /* {{{ stream_select related functions */
! 614: static int stream_array_to_fd_set(zval *stream_array, fd_set *fds, php_socket_t *max_fd TSRMLS_DC)
! 615: {
! 616: zval **elem;
! 617: php_stream *stream;
! 618: php_socket_t this_fd;
! 619: int cnt = 0;
! 620:
! 621: if (Z_TYPE_P(stream_array) != IS_ARRAY) {
! 622: return 0;
! 623: }
! 624: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream_array));
! 625: zend_hash_get_current_data(Z_ARRVAL_P(stream_array), (void **) &elem) == SUCCESS;
! 626: zend_hash_move_forward(Z_ARRVAL_P(stream_array))) {
! 627:
! 628: php_stream_from_zval_no_verify(stream, elem);
! 629: if (stream == NULL) {
! 630: continue;
! 631: }
! 632: /* get the fd.
! 633: * NB: Most other code will NOT use the PHP_STREAM_CAST_INTERNAL flag
! 634: * when casting. It is only used here so that the buffered data warning
! 635: * is not displayed.
! 636: * */
! 637: if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&this_fd, 1) && this_fd != -1) {
! 638:
! 639: PHP_SAFE_FD_SET(this_fd, fds);
! 640:
! 641: if (this_fd > *max_fd) {
! 642: *max_fd = this_fd;
! 643: }
! 644: cnt++;
! 645: }
! 646: }
! 647: return cnt ? 1 : 0;
! 648: }
! 649:
! 650: static int stream_array_from_fd_set(zval *stream_array, fd_set *fds TSRMLS_DC)
! 651: {
! 652: zval **elem, **dest_elem;
! 653: php_stream *stream;
! 654: HashTable *new_hash;
! 655: php_socket_t this_fd;
! 656: int ret = 0;
! 657:
! 658: if (Z_TYPE_P(stream_array) != IS_ARRAY) {
! 659: return 0;
! 660: }
! 661: ALLOC_HASHTABLE(new_hash);
! 662: zend_hash_init(new_hash, zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0);
! 663:
! 664: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream_array));
! 665: zend_hash_get_current_data(Z_ARRVAL_P(stream_array), (void **) &elem) == SUCCESS;
! 666: zend_hash_move_forward(Z_ARRVAL_P(stream_array))) {
! 667:
! 668: php_stream_from_zval_no_verify(stream, elem);
! 669: if (stream == NULL) {
! 670: continue;
! 671: }
! 672: /* get the fd
! 673: * NB: Most other code will NOT use the PHP_STREAM_CAST_INTERNAL flag
! 674: * when casting. It is only used here so that the buffered data warning
! 675: * is not displayed.
! 676: */
! 677: if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&this_fd, 1) && this_fd != -1) {
! 678: if (PHP_SAFE_FD_ISSET(this_fd, fds)) {
! 679: zend_hash_next_index_insert(new_hash, (void *)elem, sizeof(zval *), (void **)&dest_elem);
! 680: if (dest_elem) {
! 681: zval_add_ref(dest_elem);
! 682: }
! 683: ret++;
! 684: continue;
! 685: }
! 686: }
! 687: }
! 688:
! 689: /* destroy old array and add new one */
! 690: zend_hash_destroy(Z_ARRVAL_P(stream_array));
! 691: efree(Z_ARRVAL_P(stream_array));
! 692:
! 693: zend_hash_internal_pointer_reset(new_hash);
! 694: Z_ARRVAL_P(stream_array) = new_hash;
! 695:
! 696: return ret;
! 697: }
! 698:
! 699: static int stream_array_emulate_read_fd_set(zval *stream_array TSRMLS_DC)
! 700: {
! 701: zval **elem, **dest_elem;
! 702: php_stream *stream;
! 703: HashTable *new_hash;
! 704: int ret = 0;
! 705:
! 706: if (Z_TYPE_P(stream_array) != IS_ARRAY) {
! 707: return 0;
! 708: }
! 709: ALLOC_HASHTABLE(new_hash);
! 710: zend_hash_init(new_hash, zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0);
! 711:
! 712: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream_array));
! 713: zend_hash_get_current_data(Z_ARRVAL_P(stream_array), (void **) &elem) == SUCCESS;
! 714: zend_hash_move_forward(Z_ARRVAL_P(stream_array))) {
! 715:
! 716: php_stream_from_zval_no_verify(stream, elem);
! 717: if (stream == NULL) {
! 718: continue;
! 719: }
! 720: if ((stream->writepos - stream->readpos) > 0) {
! 721: /* allow readable non-descriptor based streams to participate in stream_select.
! 722: * Non-descriptor streams will only "work" if they have previously buffered the
! 723: * data. Not ideal, but better than nothing.
! 724: * This branch of code also allows blocking streams with buffered data to
! 725: * operate correctly in stream_select.
! 726: * */
! 727: zend_hash_next_index_insert(new_hash, (void *)elem, sizeof(zval *), (void **)&dest_elem);
! 728: if (dest_elem) {
! 729: zval_add_ref(dest_elem);
! 730: }
! 731: ret++;
! 732: continue;
! 733: }
! 734: }
! 735:
! 736: if (ret > 0) {
! 737: /* destroy old array and add new one */
! 738: zend_hash_destroy(Z_ARRVAL_P(stream_array));
! 739: efree(Z_ARRVAL_P(stream_array));
! 740:
! 741: zend_hash_internal_pointer_reset(new_hash);
! 742: Z_ARRVAL_P(stream_array) = new_hash;
! 743: } else {
! 744: zend_hash_destroy(new_hash);
! 745: FREE_HASHTABLE(new_hash);
! 746: }
! 747:
! 748: return ret;
! 749: }
! 750: /* }}} */
! 751:
! 752: /* {{{ proto int stream_select(array &read_streams, array &write_streams, array &except_streams, int tv_sec[, int tv_usec])
! 753: Runs the select() system call on the sets of streams with a timeout specified by tv_sec and tv_usec */
! 754: PHP_FUNCTION(stream_select)
! 755: {
! 756: zval *r_array, *w_array, *e_array, **sec = NULL;
! 757: struct timeval tv;
! 758: struct timeval *tv_p = NULL;
! 759: fd_set rfds, wfds, efds;
! 760: php_socket_t max_fd = 0;
! 761: int retval, sets = 0;
! 762: long usec = 0;
! 763: int set_count, max_set_count = 0;
! 764:
! 765: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!Z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE)
! 766: return;
! 767:
! 768: FD_ZERO(&rfds);
! 769: FD_ZERO(&wfds);
! 770: FD_ZERO(&efds);
! 771:
! 772: if (r_array != NULL) {
! 773: set_count = stream_array_to_fd_set(r_array, &rfds, &max_fd TSRMLS_CC);
! 774: if (set_count > max_set_count)
! 775: max_set_count = set_count;
! 776: sets += set_count;
! 777: }
! 778:
! 779: if (w_array != NULL) {
! 780: set_count = stream_array_to_fd_set(w_array, &wfds, &max_fd TSRMLS_CC);
! 781: if (set_count > max_set_count)
! 782: max_set_count = set_count;
! 783: sets += set_count;
! 784: }
! 785:
! 786: if (e_array != NULL) {
! 787: set_count = stream_array_to_fd_set(e_array, &efds, &max_fd TSRMLS_CC);
! 788: if (set_count > max_set_count)
! 789: max_set_count = set_count;
! 790: sets += set_count;
! 791: }
! 792:
! 793: if (!sets) {
! 794: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No stream arrays were passed");
! 795: RETURN_FALSE;
! 796: }
! 797:
! 798: PHP_SAFE_MAX_FD(max_fd, max_set_count);
! 799:
! 800: /* If seconds is not set to null, build the timeval, else we wait indefinitely */
! 801: if (sec != NULL) {
! 802: convert_to_long_ex(sec);
! 803:
! 804: if (Z_LVAL_PP(sec) < 0) {
! 805: php_error_docref(NULL TSRMLS_CC, E_WARNING, "The seconds parameter must be greater than 0");
! 806: RETURN_FALSE;
! 807: } else if (usec < 0) {
! 808: php_error_docref(NULL TSRMLS_CC, E_WARNING, "The microseconds parameter must be greater than 0");
! 809: RETURN_FALSE;
! 810: }
! 811:
! 812: /* Solaris + BSD do not like microsecond values which are >= 1 sec */
! 813: if (usec > 999999) {
! 814: tv.tv_sec = Z_LVAL_PP(sec) + (usec / 1000000);
! 815: tv.tv_usec = usec % 1000000;
! 816: } else {
! 817: tv.tv_sec = Z_LVAL_PP(sec);
! 818: tv.tv_usec = usec;
! 819: }
! 820:
! 821: tv_p = &tv;
! 822: }
! 823:
! 824: /* slight hack to support buffered data; if there is data sitting in the
! 825: * read buffer of any of the streams in the read array, let's pretend
! 826: * that we selected, but return only the readable sockets */
! 827: if (r_array != NULL) {
! 828:
! 829: retval = stream_array_emulate_read_fd_set(r_array TSRMLS_CC);
! 830: if (retval > 0) {
! 831: if (w_array != NULL) {
! 832: zend_hash_clean(Z_ARRVAL_P(w_array));
! 833: }
! 834: if (e_array != NULL) {
! 835: zend_hash_clean(Z_ARRVAL_P(e_array));
! 836: }
! 837: RETURN_LONG(retval);
! 838: }
! 839: }
! 840:
! 841: retval = php_select(max_fd+1, &rfds, &wfds, &efds, tv_p);
! 842:
! 843: if (retval == -1) {
! 844: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to select [%d]: %s (max_fd=%d)",
! 845: errno, strerror(errno), max_fd);
! 846: RETURN_FALSE;
! 847: }
! 848:
! 849: if (r_array != NULL) stream_array_from_fd_set(r_array, &rfds TSRMLS_CC);
! 850: if (w_array != NULL) stream_array_from_fd_set(w_array, &wfds TSRMLS_CC);
! 851: if (e_array != NULL) stream_array_from_fd_set(e_array, &efds TSRMLS_CC);
! 852:
! 853: RETURN_LONG(retval);
! 854: }
! 855: /* }}} */
! 856:
! 857: /* {{{ stream_context related functions */
! 858: static void user_space_stream_notifier(php_stream_context *context, int notifycode, int severity,
! 859: char *xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void * ptr TSRMLS_DC)
! 860: {
! 861: zval *callback = (zval*)context->notifier->ptr;
! 862: zval *retval = NULL;
! 863: zval zvs[6];
! 864: zval *ps[6];
! 865: zval **ptps[6];
! 866: int i;
! 867:
! 868: for (i = 0; i < 6; i++) {
! 869: INIT_ZVAL(zvs[i]);
! 870: ps[i] = &zvs[i];
! 871: ptps[i] = &ps[i];
! 872: MAKE_STD_ZVAL(ps[i]);
! 873: }
! 874:
! 875: ZVAL_LONG(ps[0], notifycode);
! 876: ZVAL_LONG(ps[1], severity);
! 877: if (xmsg) {
! 878: ZVAL_STRING(ps[2], xmsg, 1);
! 879: } else {
! 880: ZVAL_NULL(ps[2]);
! 881: }
! 882: ZVAL_LONG(ps[3], xcode);
! 883: ZVAL_LONG(ps[4], bytes_sofar);
! 884: ZVAL_LONG(ps[5], bytes_max);
! 885:
! 886: if (FAILURE == call_user_function_ex(EG(function_table), NULL, callback, &retval, 6, ptps, 0, NULL TSRMLS_CC)) {
! 887: php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call user notifier");
! 888: }
! 889: for (i = 0; i < 6; i++) {
! 890: zval_ptr_dtor(&ps[i]);
! 891: }
! 892: if (retval) {
! 893: zval_ptr_dtor(&retval);
! 894: }
! 895: }
! 896:
! 897: static void user_space_stream_notifier_dtor(php_stream_notifier *notifier)
! 898: {
! 899: if (notifier && notifier->ptr) {
! 900: zval_ptr_dtor((zval **)&(notifier->ptr));
! 901: notifier->ptr = NULL;
! 902: }
! 903: }
! 904:
! 905: static int parse_context_options(php_stream_context *context, zval *options TSRMLS_DC)
! 906: {
! 907: HashPosition pos, opos;
! 908: zval **wval, **oval;
! 909: char *wkey, *okey;
! 910: int wkey_len, okey_len;
! 911: int ret = SUCCESS;
! 912: ulong num_key;
! 913:
! 914: zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(options), &pos);
! 915: while (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_P(options), (void**)&wval, &pos)) {
! 916: if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_P(options), &wkey, &wkey_len, &num_key, 0, &pos)
! 917: && Z_TYPE_PP(wval) == IS_ARRAY) {
! 918:
! 919: zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(wval), &opos);
! 920: while (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(wval), (void**)&oval, &opos)) {
! 921:
! 922: if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_PP(wval), &okey, &okey_len, &num_key, 0, &opos)) {
! 923: php_stream_context_set_option(context, wkey, okey, *oval);
! 924: }
! 925: zend_hash_move_forward_ex(Z_ARRVAL_PP(wval), &opos);
! 926: }
! 927:
! 928: } else {
! 929: php_error_docref(NULL TSRMLS_CC, E_WARNING, "options should have the form [\"wrappername\"][\"optionname\"] = $value");
! 930: }
! 931: zend_hash_move_forward_ex(Z_ARRVAL_P(options), &pos);
! 932: }
! 933:
! 934: return ret;
! 935: }
! 936:
! 937: static int parse_context_params(php_stream_context *context, zval *params TSRMLS_DC)
! 938: {
! 939: int ret = SUCCESS;
! 940: zval **tmp;
! 941:
! 942: if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "notification", sizeof("notification"), (void**)&tmp)) {
! 943:
! 944: if (context->notifier) {
! 945: php_stream_notification_free(context->notifier);
! 946: context->notifier = NULL;
! 947: }
! 948:
! 949: context->notifier = php_stream_notification_alloc();
! 950: context->notifier->func = user_space_stream_notifier;
! 951: context->notifier->ptr = *tmp;
! 952: Z_ADDREF_P(*tmp);
! 953: context->notifier->dtor = user_space_stream_notifier_dtor;
! 954: }
! 955: if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) {
! 956: if (Z_TYPE_PP(tmp) == IS_ARRAY) {
! 957: parse_context_options(context, *tmp TSRMLS_CC);
! 958: } else {
! 959: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid stream/context parameter");
! 960: }
! 961: }
! 962:
! 963: return ret;
! 964: }
! 965:
! 966: /* given a zval which is either a stream or a context, return the underlying
! 967: * stream_context. If it is a stream that does not have a context assigned, it
! 968: * will create and assign a context and return that. */
! 969: static php_stream_context *decode_context_param(zval *contextresource TSRMLS_DC)
! 970: {
! 971: php_stream_context *context = NULL;
! 972:
! 973: context = zend_fetch_resource(&contextresource TSRMLS_CC, -1, NULL, NULL, 1, php_le_stream_context());
! 974: if (context == NULL) {
! 975: php_stream *stream;
! 976:
! 977: stream = zend_fetch_resource(&contextresource TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream);
! 978:
! 979: if (stream) {
! 980: context = stream->context;
! 981: if (context == NULL) {
! 982: /* Only way this happens is if file is opened with NO_DEFAULT_CONTEXT
! 983: param, but then something is called which requires a context.
! 984: Don't give them the default one though since they already said they
! 985: didn't want it. */
! 986: context = stream->context = php_stream_context_alloc();
! 987: }
! 988: }
! 989: }
! 990:
! 991: return context;
! 992: }
! 993: /* }}} */
! 994:
! 995: /* {{{ proto array stream_context_get_options(resource context|resource stream)
! 996: Retrieve options for a stream/wrapper/context */
! 997: PHP_FUNCTION(stream_context_get_options)
! 998: {
! 999: zval *zcontext;
! 1000: php_stream_context *context;
! 1001:
! 1002: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zcontext) == FAILURE) {
! 1003: RETURN_FALSE;
! 1004: }
! 1005: context = decode_context_param(zcontext TSRMLS_CC);
! 1006: if (!context) {
! 1007: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid stream/context parameter");
! 1008: RETURN_FALSE;
! 1009: }
! 1010:
! 1011: RETURN_ZVAL(context->options, 1, 0);
! 1012: }
! 1013: /* }}} */
! 1014:
! 1015: /* {{{ proto bool stream_context_set_option(resource context|resource stream, string wrappername, string optionname, mixed value)
! 1016: Set an option for a wrapper */
! 1017: PHP_FUNCTION(stream_context_set_option)
! 1018: {
! 1019: zval *options = NULL, *zcontext = NULL, *zvalue = NULL;
! 1020: php_stream_context *context;
! 1021: char *wrappername, *optionname;
! 1022: int wrapperlen, optionlen;
! 1023:
! 1024: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
! 1025: "rssz", &zcontext, &wrappername, &wrapperlen,
! 1026: &optionname, &optionlen, &zvalue) == FAILURE) {
! 1027: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
! 1028: "ra", &zcontext, &options) == FAILURE) {
! 1029: php_error_docref(NULL TSRMLS_CC, E_WARNING, "called with wrong number or type of parameters; please RTM");
! 1030: RETURN_FALSE;
! 1031: }
! 1032: }
! 1033:
! 1034: /* figure out where the context is coming from exactly */
! 1035: context = decode_context_param(zcontext TSRMLS_CC);
! 1036: if (!context) {
! 1037: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid stream/context parameter");
! 1038: RETURN_FALSE;
! 1039: }
! 1040:
! 1041: if (options) {
! 1042: /* handle the array syntax */
! 1043: RETVAL_BOOL(parse_context_options(context, options TSRMLS_CC) == SUCCESS);
! 1044: } else {
! 1045: php_stream_context_set_option(context, wrappername, optionname, zvalue);
! 1046: RETVAL_TRUE;
! 1047: }
! 1048: }
! 1049: /* }}} */
! 1050:
! 1051: /* {{{ proto bool stream_context_set_params(resource context|resource stream, array options)
! 1052: Set parameters for a file context */
! 1053: PHP_FUNCTION(stream_context_set_params)
! 1054: {
! 1055: zval *params, *zcontext;
! 1056: php_stream_context *context;
! 1057:
! 1058: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &zcontext, ¶ms) == FAILURE) {
! 1059: RETURN_FALSE;
! 1060: }
! 1061:
! 1062: context = decode_context_param(zcontext TSRMLS_CC);
! 1063: if (!context) {
! 1064: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid stream/context parameter");
! 1065: RETURN_FALSE;
! 1066: }
! 1067:
! 1068: RETVAL_BOOL(parse_context_params(context, params TSRMLS_CC) == SUCCESS);
! 1069: }
! 1070: /* }}} */
! 1071:
! 1072: /* {{{ proto array stream_context_get_params(resource context|resource stream)
! 1073: Get parameters of a file context */
! 1074: PHP_FUNCTION(stream_context_get_params)
! 1075: {
! 1076: zval *zcontext, *options;
! 1077: php_stream_context *context;
! 1078:
! 1079: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zcontext) == FAILURE) {
! 1080: RETURN_FALSE;
! 1081: }
! 1082:
! 1083: context = decode_context_param(zcontext TSRMLS_CC);
! 1084: if (!context) {
! 1085: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid stream/context parameter");
! 1086: RETURN_FALSE;
! 1087: }
! 1088:
! 1089: array_init(return_value);
! 1090: if (context->notifier && context->notifier->ptr && context->notifier->func == user_space_stream_notifier) {
! 1091: add_assoc_zval_ex(return_value, ZEND_STRS("notification"), context->notifier->ptr);
! 1092: Z_ADDREF_P(context->notifier->ptr);
! 1093: }
! 1094: ALLOC_INIT_ZVAL(options);
! 1095: ZVAL_ZVAL(options, context->options, 1, 0);
! 1096: add_assoc_zval_ex(return_value, ZEND_STRS("options"), options);
! 1097: }
! 1098: /* }}} */
! 1099:
! 1100: /* {{{ proto resource stream_context_get_default([array options])
! 1101: Get a handle on the default file/stream context and optionally set parameters */
! 1102: PHP_FUNCTION(stream_context_get_default)
! 1103: {
! 1104: zval *params = NULL;
! 1105: php_stream_context *context;
! 1106:
! 1107: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", ¶ms) == FAILURE) {
! 1108: RETURN_FALSE;
! 1109: }
! 1110:
! 1111: if (FG(default_context) == NULL) {
! 1112: FG(default_context) = php_stream_context_alloc();
! 1113: }
! 1114: context = FG(default_context);
! 1115:
! 1116: if (params) {
! 1117: parse_context_options(context, params TSRMLS_CC);
! 1118: }
! 1119:
! 1120: php_stream_context_to_zval(context, return_value);
! 1121: }
! 1122: /* }}} */
! 1123:
! 1124: /* {{{ proto resource stream_context_set_default(array options)
! 1125: Set default file/stream context, returns the context as a resource */
! 1126: PHP_FUNCTION(stream_context_set_default)
! 1127: {
! 1128: zval *options = NULL;
! 1129: php_stream_context *context;
! 1130:
! 1131: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &options) == FAILURE) {
! 1132: return;
! 1133: }
! 1134:
! 1135: if (FG(default_context) == NULL) {
! 1136: FG(default_context) = php_stream_context_alloc();
! 1137: }
! 1138: context = FG(default_context);
! 1139:
! 1140: parse_context_options(context, options TSRMLS_CC);
! 1141:
! 1142: php_stream_context_to_zval(context, return_value);
! 1143: }
! 1144: /* }}} */
! 1145:
! 1146: /* {{{ proto resource stream_context_create([array options[, array params]])
! 1147: Create a file context and optionally set parameters */
! 1148: PHP_FUNCTION(stream_context_create)
! 1149: {
! 1150: zval *options = NULL, *params = NULL;
! 1151: php_stream_context *context;
! 1152:
! 1153: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!a!", &options, ¶ms) == FAILURE) {
! 1154: RETURN_FALSE;
! 1155: }
! 1156:
! 1157: context = php_stream_context_alloc();
! 1158:
! 1159: if (options) {
! 1160: parse_context_options(context, options TSRMLS_CC);
! 1161: }
! 1162:
! 1163: if (params) {
! 1164: parse_context_params(context, params TSRMLS_CC);
! 1165: }
! 1166:
! 1167: RETURN_RESOURCE(context->rsrc_id);
! 1168: }
! 1169: /* }}} */
! 1170:
! 1171: /* {{{ streams filter functions */
! 1172: static void apply_filter_to_stream(int append, INTERNAL_FUNCTION_PARAMETERS)
! 1173: {
! 1174: zval *zstream;
! 1175: php_stream *stream;
! 1176: char *filtername;
! 1177: int filternamelen;
! 1178: long read_write = 0;
! 1179: zval *filterparams = NULL;
! 1180: php_stream_filter *filter = NULL;
! 1181: int ret;
! 1182:
! 1183: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|lz", &zstream,
! 1184: &filtername, &filternamelen, &read_write, &filterparams) == FAILURE) {
! 1185: RETURN_FALSE;
! 1186: }
! 1187:
! 1188: php_stream_from_zval(stream, &zstream);
! 1189:
! 1190: if ((read_write & PHP_STREAM_FILTER_ALL) == 0) {
! 1191: /* Chain not specified.
! 1192: * Examine stream->mode to determine which filters are needed
! 1193: * There's no harm in attaching a filter to an unused chain,
! 1194: * but why waste the memory and clock cycles?
! 1195: */
! 1196: if (strchr(stream->mode, 'r') || strchr(stream->mode, '+')) {
! 1197: read_write |= PHP_STREAM_FILTER_READ;
! 1198: }
! 1199: if (strchr(stream->mode, 'w') || strchr(stream->mode, '+') || strchr(stream->mode, 'a')) {
! 1200: read_write |= PHP_STREAM_FILTER_WRITE;
! 1201: }
! 1202: }
! 1203:
! 1204: if (read_write & PHP_STREAM_FILTER_READ) {
! 1205: filter = php_stream_filter_create(filtername, filterparams, php_stream_is_persistent(stream) TSRMLS_CC);
! 1206: if (filter == NULL) {
! 1207: RETURN_FALSE;
! 1208: }
! 1209:
! 1210: if (append) {
! 1211: ret = php_stream_filter_append_ex(&stream->readfilters, filter TSRMLS_CC);
! 1212: } else {
! 1213: ret = php_stream_filter_prepend_ex(&stream->readfilters, filter TSRMLS_CC);
! 1214: }
! 1215: if (ret != SUCCESS) {
! 1216: php_stream_filter_remove(filter, 1 TSRMLS_CC);
! 1217: RETURN_FALSE;
! 1218: }
! 1219: }
! 1220:
! 1221: if (read_write & PHP_STREAM_FILTER_WRITE) {
! 1222: filter = php_stream_filter_create(filtername, filterparams, php_stream_is_persistent(stream) TSRMLS_CC);
! 1223: if (filter == NULL) {
! 1224: RETURN_FALSE;
! 1225: }
! 1226:
! 1227: if (append) {
! 1228: ret = php_stream_filter_append_ex(&stream->writefilters, filter TSRMLS_CC);
! 1229: } else {
! 1230: ret = php_stream_filter_prepend_ex(&stream->writefilters, filter TSRMLS_CC);
! 1231: }
! 1232: if (ret != SUCCESS) {
! 1233: php_stream_filter_remove(filter, 1 TSRMLS_CC);
! 1234: RETURN_FALSE;
! 1235: }
! 1236: }
! 1237:
! 1238: if (filter) {
! 1239: RETURN_RESOURCE(filter->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, filter, php_file_le_stream_filter()));
! 1240: } else {
! 1241: RETURN_FALSE;
! 1242: }
! 1243: }
! 1244: /* }}} */
! 1245:
! 1246: /* {{{ proto resource stream_filter_prepend(resource stream, string filtername[, int read_write[, string filterparams]])
! 1247: Prepend a filter to a stream */
! 1248: PHP_FUNCTION(stream_filter_prepend)
! 1249: {
! 1250: apply_filter_to_stream(0, INTERNAL_FUNCTION_PARAM_PASSTHRU);
! 1251: }
! 1252: /* }}} */
! 1253:
! 1254: /* {{{ proto resource stream_filter_append(resource stream, string filtername[, int read_write[, string filterparams]])
! 1255: Append a filter to a stream */
! 1256: PHP_FUNCTION(stream_filter_append)
! 1257: {
! 1258: apply_filter_to_stream(1, INTERNAL_FUNCTION_PARAM_PASSTHRU);
! 1259: }
! 1260: /* }}} */
! 1261:
! 1262: /* {{{ proto bool stream_filter_remove(resource stream_filter)
! 1263: Flushes any data in the filter's internal buffer, removes it from the chain, and frees the resource */
! 1264: PHP_FUNCTION(stream_filter_remove)
! 1265: {
! 1266: zval *zfilter;
! 1267: php_stream_filter *filter;
! 1268:
! 1269: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zfilter) == FAILURE) {
! 1270: RETURN_FALSE;
! 1271: }
! 1272:
! 1273: filter = zend_fetch_resource(&zfilter TSRMLS_CC, -1, NULL, NULL, 1, php_file_le_stream_filter());
! 1274: if (!filter) {
! 1275: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid resource given, not a stream filter");
! 1276: RETURN_FALSE;
! 1277: }
! 1278:
! 1279: if (php_stream_filter_flush(filter, 1) == FAILURE) {
! 1280: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to flush filter, not removing");
! 1281: RETURN_FALSE;
! 1282: }
! 1283:
! 1284: if (zend_list_delete(Z_LVAL_P(zfilter)) == FAILURE) {
! 1285: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not invalidate filter, not removing");
! 1286: RETURN_FALSE;
! 1287: } else {
! 1288: php_stream_filter_remove(filter, 1 TSRMLS_CC);
! 1289: RETURN_TRUE;
! 1290: }
! 1291: }
! 1292: /* }}} */
! 1293:
! 1294: /* {{{ proto string stream_get_line(resource stream, int maxlen [, string ending])
! 1295: Read up to maxlen bytes from a stream or until the ending string is found */
! 1296: PHP_FUNCTION(stream_get_line)
! 1297: {
! 1298: char *str = NULL;
! 1299: int str_len = 0;
! 1300: long max_length;
! 1301: zval *zstream;
! 1302: char *buf;
! 1303: size_t buf_size;
! 1304: php_stream *stream;
! 1305:
! 1306: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|s", &zstream, &max_length, &str, &str_len) == FAILURE) {
! 1307: RETURN_FALSE;
! 1308: }
! 1309:
! 1310: if (max_length < 0) {
! 1311: php_error_docref(NULL TSRMLS_CC, E_WARNING, "The maximum allowed length must be greater than or equal to zero");
! 1312: RETURN_FALSE;
! 1313: }
! 1314: if (!max_length) {
! 1315: max_length = PHP_SOCK_CHUNK_SIZE;
! 1316: }
! 1317:
! 1318: php_stream_from_zval(stream, &zstream);
! 1319:
! 1320: if ((buf = php_stream_get_record(stream, max_length, &buf_size, str, str_len TSRMLS_CC))) {
! 1321: RETURN_STRINGL(buf, buf_size, 0);
! 1322: } else {
! 1323: RETURN_FALSE;
! 1324: }
! 1325: }
! 1326:
! 1327: /* }}} */
! 1328:
! 1329: /* {{{ proto bool stream_set_blocking(resource socket, int mode)
! 1330: Set blocking/non-blocking mode on a socket or stream */
! 1331: PHP_FUNCTION(stream_set_blocking)
! 1332: {
! 1333: zval *arg1;
! 1334: int block;
! 1335: long arg2;
! 1336: php_stream *stream;
! 1337:
! 1338: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &arg1, &arg2) == FAILURE) {
! 1339: return;
! 1340: }
! 1341:
! 1342: php_stream_from_zval(stream, &arg1);
! 1343:
! 1344: block = arg2;
! 1345:
! 1346: if (php_stream_set_option(stream, PHP_STREAM_OPTION_BLOCKING, block == 0 ? 0 : 1, NULL) == -1) {
! 1347: RETURN_FALSE;
! 1348: }
! 1349:
! 1350: RETURN_TRUE;
! 1351: }
! 1352:
! 1353: /* }}} */
! 1354:
! 1355: /* {{{ proto bool stream_set_timeout(resource stream, int seconds [, int microseconds])
! 1356: Set timeout on stream read to seconds + microseonds */
! 1357: #if HAVE_SYS_TIME_H || defined(PHP_WIN32)
! 1358: PHP_FUNCTION(stream_set_timeout)
! 1359: {
! 1360: zval *socket;
! 1361: long seconds, microseconds = 0;
! 1362: struct timeval t;
! 1363: php_stream *stream;
! 1364: int argc = ZEND_NUM_ARGS();
! 1365:
! 1366: if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &socket, &seconds, µseconds) == FAILURE) {
! 1367: return;
! 1368: }
! 1369:
! 1370: php_stream_from_zval(stream, &socket);
! 1371:
! 1372: t.tv_sec = seconds;
! 1373:
! 1374: if (argc == 3) {
! 1375: t.tv_usec = microseconds % 1000000;
! 1376: t.tv_sec += microseconds / 1000000;
! 1377: } else {
! 1378: t.tv_usec = 0;
! 1379: }
! 1380:
! 1381: if (PHP_STREAM_OPTION_RETURN_OK == php_stream_set_option(stream, PHP_STREAM_OPTION_READ_TIMEOUT, 0, &t)) {
! 1382: RETURN_TRUE;
! 1383: }
! 1384:
! 1385: RETURN_FALSE;
! 1386: }
! 1387: #endif /* HAVE_SYS_TIME_H || defined(PHP_WIN32) */
! 1388: /* }}} */
! 1389:
! 1390: /* {{{ proto int stream_set_write_buffer(resource fp, int buffer)
! 1391: Set file write buffer */
! 1392: PHP_FUNCTION(stream_set_write_buffer)
! 1393: {
! 1394: zval *arg1;
! 1395: int ret;
! 1396: long arg2;
! 1397: size_t buff;
! 1398: php_stream *stream;
! 1399:
! 1400: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &arg1, &arg2) == FAILURE) {
! 1401: RETURN_FALSE;
! 1402: }
! 1403:
! 1404: php_stream_from_zval(stream, &arg1);
! 1405:
! 1406: buff = arg2;
! 1407:
! 1408: /* if buff is 0 then set to non-buffered */
! 1409: if (buff == 0) {
! 1410: ret = php_stream_set_option(stream, PHP_STREAM_OPTION_WRITE_BUFFER, PHP_STREAM_BUFFER_NONE, NULL);
! 1411: } else {
! 1412: ret = php_stream_set_option(stream, PHP_STREAM_OPTION_WRITE_BUFFER, PHP_STREAM_BUFFER_FULL, &buff);
! 1413: }
! 1414:
! 1415: RETURN_LONG(ret == 0 ? 0 : EOF);
! 1416: }
! 1417: /* }}} */
! 1418:
! 1419: /* {{{ proto int stream_set_read_buffer(resource fp, int buffer)
! 1420: Set file read buffer */
! 1421: PHP_FUNCTION(stream_set_read_buffer)
! 1422: {
! 1423: zval *arg1;
! 1424: int ret;
! 1425: long arg2;
! 1426: size_t buff;
! 1427: php_stream *stream;
! 1428:
! 1429: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &arg1, &arg2) == FAILURE) {
! 1430: RETURN_FALSE;
! 1431: }
! 1432:
! 1433: php_stream_from_zval(stream, &arg1);
! 1434:
! 1435: buff = arg2;
! 1436:
! 1437: /* if buff is 0 then set to non-buffered */
! 1438: if (buff == 0) {
! 1439: ret = php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER, PHP_STREAM_BUFFER_NONE, NULL);
! 1440: } else {
! 1441: ret = php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER, PHP_STREAM_BUFFER_FULL, &buff);
! 1442: }
! 1443:
! 1444: RETURN_LONG(ret == 0 ? 0 : EOF);
! 1445: }
! 1446: /* }}} */
! 1447:
! 1448: /* {{{ proto int stream_socket_enable_crypto(resource stream, bool enable [, int cryptokind [, resource sessionstream]])
! 1449: Enable or disable a specific kind of crypto on the stream */
! 1450: PHP_FUNCTION(stream_socket_enable_crypto)
! 1451: {
! 1452: long cryptokind = 0;
! 1453: zval *zstream, *zsessstream = NULL;
! 1454: php_stream *stream, *sessstream = NULL;
! 1455: zend_bool enable;
! 1456: int ret;
! 1457:
! 1458: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb|lr", &zstream, &enable, &cryptokind, &zsessstream) == FAILURE) {
! 1459: RETURN_FALSE;
! 1460: }
! 1461:
! 1462: php_stream_from_zval(stream, &zstream);
! 1463:
! 1464: if (ZEND_NUM_ARGS() >= 3) {
! 1465: if (zsessstream) {
! 1466: php_stream_from_zval(sessstream, &zsessstream);
! 1467: }
! 1468:
! 1469: if (php_stream_xport_crypto_setup(stream, cryptokind, sessstream TSRMLS_CC) < 0) {
! 1470: RETURN_FALSE;
! 1471: }
! 1472: } else if (enable) {
! 1473: php_error_docref(NULL TSRMLS_CC, E_WARNING, "When enabling encryption you must specify the crypto type");
! 1474: RETURN_FALSE;
! 1475: }
! 1476:
! 1477: ret = php_stream_xport_crypto_enable(stream, enable TSRMLS_CC);
! 1478: switch (ret) {
! 1479: case -1:
! 1480: RETURN_FALSE;
! 1481:
! 1482: case 0:
! 1483: RETURN_LONG(0);
! 1484:
! 1485: default:
! 1486: RETURN_TRUE;
! 1487: }
! 1488: }
! 1489: /* }}} */
! 1490:
! 1491: /* {{{ proto string stream_resolve_include_path(string filename)
! 1492: Determine what file will be opened by calls to fopen() with a relative path */
! 1493: PHP_FUNCTION(stream_resolve_include_path)
! 1494: {
! 1495: char *filename, *resolved_path;
! 1496: int filename_len;
! 1497:
! 1498: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
! 1499: return;
! 1500: }
! 1501:
! 1502: resolved_path = zend_resolve_path(filename, filename_len TSRMLS_CC);
! 1503:
! 1504: if (resolved_path) {
! 1505: RETURN_STRING(resolved_path, 0);
! 1506: }
! 1507: RETURN_FALSE;
! 1508: }
! 1509: /* }}} */
! 1510:
! 1511: /* {{{ proto bool stream_is_local(resource stream|string url) U
! 1512: */
! 1513: PHP_FUNCTION(stream_is_local)
! 1514: {
! 1515: zval **zstream;
! 1516: php_stream *stream = NULL;
! 1517: php_stream_wrapper *wrapper = NULL;
! 1518:
! 1519: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &zstream) == FAILURE) {
! 1520: RETURN_FALSE;
! 1521: }
! 1522:
! 1523: if (Z_TYPE_PP(zstream) == IS_RESOURCE) {
! 1524: php_stream_from_zval(stream, zstream);
! 1525: if (stream == NULL) {
! 1526: RETURN_FALSE;
! 1527: }
! 1528: wrapper = stream->wrapper;
! 1529: } else {
! 1530: convert_to_string_ex(zstream);
! 1531:
! 1532: wrapper = php_stream_locate_url_wrapper(Z_STRVAL_PP(zstream), NULL, 0 TSRMLS_CC);
! 1533: }
! 1534:
! 1535: if (!wrapper) {
! 1536: RETURN_FALSE;
! 1537: }
! 1538:
! 1539: RETURN_BOOL(wrapper->is_url==0);
! 1540: }
! 1541: /* }}} */
! 1542:
! 1543: /* {{{ proto bool stream_supports_lock(resource stream)
! 1544: Tells wether the stream supports locking through flock(). */
! 1545: PHP_FUNCTION(stream_supports_lock)
! 1546: {
! 1547: php_stream *stream;
! 1548: zval *zsrc;
! 1549:
! 1550: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zsrc) == FAILURE) {
! 1551: RETURN_FALSE;
! 1552: }
! 1553:
! 1554: php_stream_from_zval(stream, &zsrc);
! 1555:
! 1556: if (!php_stream_supports_lock(stream)) {
! 1557: RETURN_FALSE;
! 1558: }
! 1559:
! 1560: RETURN_TRUE;
! 1561: }
! 1562:
! 1563: #ifdef HAVE_SHUTDOWN
! 1564: /* {{{ proto int stream_socket_shutdown(resource stream, int how)
! 1565: causes all or part of a full-duplex connection on the socket associated
! 1566: with stream to be shut down. If how is SHUT_RD, further receptions will
! 1567: be disallowed. If how is SHUT_WR, further transmissions will be disallowed.
! 1568: If how is SHUT_RDWR, further receptions and transmissions will be
! 1569: disallowed. */
! 1570: PHP_FUNCTION(stream_socket_shutdown)
! 1571: {
! 1572: long how;
! 1573: zval *zstream;
! 1574: php_stream *stream;
! 1575:
! 1576: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zstream, &how) == FAILURE) {
! 1577: RETURN_FALSE;
! 1578: }
! 1579:
! 1580: if (how != STREAM_SHUT_RD &&
! 1581: how != STREAM_SHUT_WR &&
! 1582: how != STREAM_SHUT_RDWR) {
! 1583: RETURN_FALSE;
! 1584: }
! 1585:
! 1586: php_stream_from_zval(stream, &zstream);
! 1587:
! 1588: RETURN_BOOL(php_stream_xport_shutdown(stream, (stream_shutdown_t)how TSRMLS_CC) == 0);
! 1589: }
! 1590: /* }}} */
! 1591: #endif
! 1592:
! 1593: /*
! 1594: * Local variables:
! 1595: * tab-width: 4
! 1596: * c-basic-offset: 4
! 1597: * End:
! 1598: * vim600: noet sw=4 ts=4 fdm=marker
! 1599: * vim<600: noet sw=4 ts=4
! 1600: */
! 1601:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to streamsfuncs.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 / ext / standard