1 /* 2 +----------------------------------------------------------------------+ 3 | PHP Version 7 | 4 +----------------------------------------------------------------------+ 5 | Copyright (c) 1997-2018 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: Rasmus Lerdorf <rasmus@php.net> | 16 | Stig Bakken <ssb@php.net> | 17 | Andi Gutmans <andi@php.net> | 18 | Zeev Suraski <zeev@php.net> | 19 | PHP 4.0 patches by Thies C. Arntzen (thies@thieso.net) | 20 | PHP streams by Wez Furlong (wez@thebrainroom.com) | 21 +----------------------------------------------------------------------+ 22 */ 23 24 /* {{{ includes */ 25 26 #include "php.h" 27 #include "php_globals.h" 28 #include "ext/standard/flock_compat.h" 29 #include "ext/standard/exec.h" 30 #include "ext/standard/php_filestat.h" 31 #include "php_open_temporary_file.h" 32 #include "ext/standard/basic_functions.h" 33 #include "php_ini.h" 34 #include "zend_smart_str.h" 35 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <errno.h> 39 #include <sys/types.h> 40 #include <sys/stat.h> 41 #include <fcntl.h> 42 43 #ifdef PHP_WIN32 44 # include <io.h> 45 # define O_RDONLY _O_RDONLY 46 # include "win32/param.h" 47 # include "win32/winutil.h" 48 # include "win32/fnmatch.h" 49 # include "win32/ioutil.h" 50 #else 51 # if HAVE_SYS_PARAM_H 52 # include <sys/param.h> 53 # endif 54 # if HAVE_SYS_SELECT_H 55 # include <sys/select.h> 56 # endif 57 # include <sys/socket.h> 58 # include <netinet/in.h> 59 # include <netdb.h> 60 # if HAVE_ARPA_INET_H 61 # include <arpa/inet.h> 62 # endif 63 #endif 64 65 #include "ext/standard/head.h" 66 #include "php_string.h" 67 #include "file.h" 68 69 #if HAVE_PWD_H 70 # ifdef PHP_WIN32 71 # include "win32/pwd.h" 72 # else 73 # include <pwd.h> 74 # endif 75 #endif 76 77 #ifdef HAVE_SYS_TIME_H 78 # include <sys/time.h> 79 #endif 80 81 #include "fsock.h" 82 #include "fopen_wrappers.h" 83 #include "streamsfuncs.h" 84 #include "php_globals.h" 85 86 #ifdef HAVE_SYS_FILE_H 87 # include <sys/file.h> 88 #endif 89 90 #if MISSING_FCLOSE_DECL 91 extern int fclose(FILE *); 92 #endif 93 94 #ifdef HAVE_SYS_MMAN_H 95 # include <sys/mman.h> 96 #endif 97 98 #include "scanf.h" 99 #include "zend_API.h" 100 101 #ifdef ZTS 102 int file_globals_id; 103 #else 104 php_file_globals file_globals; 105 #endif 106 107 #if defined(HAVE_FNMATCH) && !defined(PHP_WIN32) 108 # ifndef _GNU_SOURCE 109 # define _GNU_SOURCE 110 # endif 111 # include <fnmatch.h> 112 #endif 113 114 #ifdef HAVE_WCHAR_H 115 # include <wchar.h> 116 #endif 117 118 /* }}} */ 119 120 #define PHP_STREAM_TO_ZVAL(stream, arg) \ 121 ZEND_ASSERT(Z_TYPE_P(arg) == IS_RESOURCE); \ 122 php_stream_from_res(stream, Z_RES_P(arg)); 123 124 /* {{{ ZTS-stuff / Globals / Prototypes */ 125 126 /* sharing globals is *evil* */ 127 static int le_stream_context = FAILURE; 128 129 PHPAPI int php_le_stream_context(void) 130 { 131 return le_stream_context; 132 } 133 /* }}} */ 134 135 /* {{{ Module-Stuff 136 */ 137 static ZEND_RSRC_DTOR_FUNC(file_context_dtor) 138 { 139 php_stream_context *context = (php_stream_context*)res->ptr; 140 if (Z_TYPE(context->options) != IS_UNDEF) { 141 zval_ptr_dtor(&context->options); 142 ZVAL_UNDEF(&context->options); 143 } 144 php_stream_context_free(context); 145 } 146 147 static void file_globals_ctor(php_file_globals *file_globals_p) 148 { 149 memset(file_globals_p, 0, sizeof(php_file_globals)); 150 file_globals_p->def_chunk_size = PHP_SOCK_CHUNK_SIZE; 151 } 152 153 static void file_globals_dtor(php_file_globals *file_globals_p) 154 { 155 #if defined(HAVE_GETHOSTBYNAME_R) 156 if (file_globals_p->tmp_host_buf) { 157 free(file_globals_p->tmp_host_buf); 158 } 159 #endif 160 } 161 162 PHP_INI_BEGIN() 163 STD_PHP_INI_ENTRY("user_agent", NULL, PHP_INI_ALL, OnUpdateString, user_agent, php_file_globals, file_globals) 164 STD_PHP_INI_ENTRY("from", NULL, PHP_INI_ALL, OnUpdateString, from_address, php_file_globals, file_globals) 165 STD_PHP_INI_ENTRY("default_socket_timeout", "60", PHP_INI_ALL, OnUpdateLong, default_socket_timeout, php_file_globals, file_globals) 166 STD_PHP_INI_ENTRY("auto_detect_line_endings", "0", PHP_INI_ALL, OnUpdateBool, auto_detect_line_endings, php_file_globals, file_globals) 167 PHP_INI_END() 168 169 PHP_MINIT_FUNCTION(file) 170 { 171 le_stream_context = zend_register_list_destructors_ex(file_context_dtor, NULL, "stream-context", module_number); 172 173 #ifdef ZTS 174 ts_allocate_id(&file_globals_id, sizeof(php_file_globals), (ts_allocate_ctor) file_globals_ctor, (ts_allocate_dtor) file_globals_dtor); 175 #else 176 file_globals_ctor(&file_globals); 177 #endif 178 179 REGISTER_INI_ENTRIES(); 180 181 REGISTER_LONG_CONSTANT("SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT); 182 REGISTER_LONG_CONSTANT("SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT); 183 REGISTER_LONG_CONSTANT("SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT); 184 REGISTER_LONG_CONSTANT("LOCK_SH", PHP_LOCK_SH, CONST_CS | CONST_PERSISTENT); 185 REGISTER_LONG_CONSTANT("LOCK_EX", PHP_LOCK_EX, CONST_CS | CONST_PERSISTENT); 186 REGISTER_LONG_CONSTANT("LOCK_UN", PHP_LOCK_UN, CONST_CS | CONST_PERSISTENT); 187 REGISTER_LONG_CONSTANT("LOCK_NB", PHP_LOCK_NB, CONST_CS | CONST_PERSISTENT); 188 189 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_CONNECT", PHP_STREAM_NOTIFY_CONNECT, CONST_CS | CONST_PERSISTENT); 190 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_AUTH_REQUIRED", PHP_STREAM_NOTIFY_AUTH_REQUIRED, CONST_CS | CONST_PERSISTENT); 191 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_AUTH_RESULT", PHP_STREAM_NOTIFY_AUTH_RESULT, CONST_CS | CONST_PERSISTENT); 192 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_MIME_TYPE_IS", PHP_STREAM_NOTIFY_MIME_TYPE_IS, CONST_CS | CONST_PERSISTENT); 193 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_FILE_SIZE_IS", PHP_STREAM_NOTIFY_FILE_SIZE_IS, CONST_CS | CONST_PERSISTENT); 194 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_REDIRECTED", PHP_STREAM_NOTIFY_REDIRECTED, CONST_CS | CONST_PERSISTENT); 195 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_PROGRESS", PHP_STREAM_NOTIFY_PROGRESS, CONST_CS | CONST_PERSISTENT); 196 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_FAILURE", PHP_STREAM_NOTIFY_FAILURE, CONST_CS | CONST_PERSISTENT); 197 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_COMPLETED", PHP_STREAM_NOTIFY_COMPLETED, CONST_CS | CONST_PERSISTENT); 198 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_RESOLVE", PHP_STREAM_NOTIFY_RESOLVE, CONST_CS | CONST_PERSISTENT); 199 200 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_INFO", PHP_STREAM_NOTIFY_SEVERITY_INFO, CONST_CS | CONST_PERSISTENT); 201 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_WARN", PHP_STREAM_NOTIFY_SEVERITY_WARN, CONST_CS | CONST_PERSISTENT); 202 REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_ERR", PHP_STREAM_NOTIFY_SEVERITY_ERR, CONST_CS | CONST_PERSISTENT); 203 204 REGISTER_LONG_CONSTANT("STREAM_FILTER_READ", PHP_STREAM_FILTER_READ, CONST_CS | CONST_PERSISTENT); 205 REGISTER_LONG_CONSTANT("STREAM_FILTER_WRITE", PHP_STREAM_FILTER_WRITE, CONST_CS | CONST_PERSISTENT); 206 REGISTER_LONG_CONSTANT("STREAM_FILTER_ALL", PHP_STREAM_FILTER_ALL, CONST_CS | CONST_PERSISTENT); 207 208 REGISTER_LONG_CONSTANT("STREAM_CLIENT_PERSISTENT", PHP_STREAM_CLIENT_PERSISTENT, CONST_CS | CONST_PERSISTENT); 209 REGISTER_LONG_CONSTANT("STREAM_CLIENT_ASYNC_CONNECT", PHP_STREAM_CLIENT_ASYNC_CONNECT, CONST_CS | CONST_PERSISTENT); 210 REGISTER_LONG_CONSTANT("STREAM_CLIENT_CONNECT", PHP_STREAM_CLIENT_CONNECT, CONST_CS | CONST_PERSISTENT); 211 212 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_ANY_CLIENT", STREAM_CRYPTO_METHOD_ANY_CLIENT, CONST_CS|CONST_PERSISTENT); 213 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_CLIENT", STREAM_CRYPTO_METHOD_SSLv2_CLIENT, CONST_CS|CONST_PERSISTENT); 214 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_CLIENT", STREAM_CRYPTO_METHOD_SSLv3_CLIENT, CONST_CS|CONST_PERSISTENT); 215 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_CLIENT", STREAM_CRYPTO_METHOD_SSLv23_CLIENT, CONST_CS|CONST_PERSISTENT); 216 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLS_CLIENT", STREAM_CRYPTO_METHOD_TLS_CLIENT, CONST_CS|CONST_PERSISTENT); 217 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT, CONST_CS|CONST_PERSISTENT); 218 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT, CONST_CS|CONST_PERSISTENT); 219 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT, CONST_CS|CONST_PERSISTENT); 220 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_ANY_SERVER", STREAM_CRYPTO_METHOD_ANY_SERVER, CONST_CS|CONST_PERSISTENT); 221 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_SERVER", STREAM_CRYPTO_METHOD_SSLv2_SERVER, CONST_CS|CONST_PERSISTENT); 222 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_SERVER", STREAM_CRYPTO_METHOD_SSLv3_SERVER, CONST_CS|CONST_PERSISTENT); 223 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_SERVER", STREAM_CRYPTO_METHOD_SSLv23_SERVER, CONST_CS|CONST_PERSISTENT); 224 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLS_SERVER", STREAM_CRYPTO_METHOD_TLS_SERVER, CONST_CS|CONST_PERSISTENT); 225 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_SERVER", STREAM_CRYPTO_METHOD_TLSv1_0_SERVER, CONST_CS|CONST_PERSISTENT); 226 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_SERVER", STREAM_CRYPTO_METHOD_TLSv1_1_SERVER, CONST_CS|CONST_PERSISTENT); 227 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_SERVER", STREAM_CRYPTO_METHOD_TLSv1_2_SERVER, CONST_CS|CONST_PERSISTENT); 228 229 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_PROTO_SSLv3", STREAM_CRYPTO_METHOD_SSLv3_SERVER, CONST_CS|CONST_PERSISTENT); 230 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_PROTO_TLSv1_0", STREAM_CRYPTO_METHOD_TLSv1_0_SERVER, CONST_CS|CONST_PERSISTENT); 231 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_PROTO_TLSv1_1", STREAM_CRYPTO_METHOD_TLSv1_1_SERVER, CONST_CS|CONST_PERSISTENT); 232 REGISTER_LONG_CONSTANT("STREAM_CRYPTO_PROTO_TLSv1_2", STREAM_CRYPTO_METHOD_TLSv1_2_SERVER, CONST_CS|CONST_PERSISTENT); 233 234 REGISTER_LONG_CONSTANT("STREAM_SHUT_RD", STREAM_SHUT_RD, CONST_CS|CONST_PERSISTENT); 235 REGISTER_LONG_CONSTANT("STREAM_SHUT_WR", STREAM_SHUT_WR, CONST_CS|CONST_PERSISTENT); 236 REGISTER_LONG_CONSTANT("STREAM_SHUT_RDWR", STREAM_SHUT_RDWR, CONST_CS|CONST_PERSISTENT); 237 238 #ifdef PF_INET 239 REGISTER_LONG_CONSTANT("STREAM_PF_INET", PF_INET, CONST_CS|CONST_PERSISTENT); 240 #elif defined(AF_INET) 241 REGISTER_LONG_CONSTANT("STREAM_PF_INET", AF_INET, CONST_CS|CONST_PERSISTENT); 242 #endif 243 244 #if HAVE_IPV6 245 # ifdef PF_INET6 246 REGISTER_LONG_CONSTANT("STREAM_PF_INET6", PF_INET6, CONST_CS|CONST_PERSISTENT); 247 # elif defined(AF_INET6) 248 REGISTER_LONG_CONSTANT("STREAM_PF_INET6", AF_INET6, CONST_CS|CONST_PERSISTENT); 249 # endif 250 #endif 251 252 #ifdef PF_UNIX 253 REGISTER_LONG_CONSTANT("STREAM_PF_UNIX", PF_UNIX, CONST_CS|CONST_PERSISTENT); 254 #elif defined(AF_UNIX) 255 REGISTER_LONG_CONSTANT("STREAM_PF_UNIX", AF_UNIX, CONST_CS|CONST_PERSISTENT); 256 #endif 257 258 #ifdef IPPROTO_IP 259 /* most people will use this one when calling socket() or socketpair() */ 260 REGISTER_LONG_CONSTANT("STREAM_IPPROTO_IP", IPPROTO_IP, CONST_CS|CONST_PERSISTENT); 261 #endif 262 263 #if defined(IPPROTO_TCP) || defined(PHP_WIN32) 264 REGISTER_LONG_CONSTANT("STREAM_IPPROTO_TCP", IPPROTO_TCP, CONST_CS|CONST_PERSISTENT); 265 #endif 266 267 #if defined(IPPROTO_UDP) || defined(PHP_WIN32) 268 REGISTER_LONG_CONSTANT("STREAM_IPPROTO_UDP", IPPROTO_UDP, CONST_CS|CONST_PERSISTENT); 269 #endif 270 271 #if defined(IPPROTO_ICMP) || defined(PHP_WIN32) 272 REGISTER_LONG_CONSTANT("STREAM_IPPROTO_ICMP", IPPROTO_ICMP, CONST_CS|CONST_PERSISTENT); 273 #endif 274 275 #if defined(IPPROTO_RAW) || defined(PHP_WIN32) 276 REGISTER_LONG_CONSTANT("STREAM_IPPROTO_RAW", IPPROTO_RAW, CONST_CS|CONST_PERSISTENT); 277 #endif 278 279 REGISTER_LONG_CONSTANT("STREAM_SOCK_STREAM", SOCK_STREAM, CONST_CS|CONST_PERSISTENT); 280 REGISTER_LONG_CONSTANT("STREAM_SOCK_DGRAM", SOCK_DGRAM, CONST_CS|CONST_PERSISTENT); 281 282 #ifdef SOCK_RAW 283 REGISTER_LONG_CONSTANT("STREAM_SOCK_RAW", SOCK_RAW, CONST_CS|CONST_PERSISTENT); 284 #endif 285 286 #ifdef SOCK_SEQPACKET 287 REGISTER_LONG_CONSTANT("STREAM_SOCK_SEQPACKET", SOCK_SEQPACKET, CONST_CS|CONST_PERSISTENT); 288 #endif 289 290 #ifdef SOCK_RDM 291 REGISTER_LONG_CONSTANT("STREAM_SOCK_RDM", SOCK_RDM, CONST_CS|CONST_PERSISTENT); 292 #endif 293 294 REGISTER_LONG_CONSTANT("STREAM_PEEK", STREAM_PEEK, CONST_CS | CONST_PERSISTENT); 295 REGISTER_LONG_CONSTANT("STREAM_OOB", STREAM_OOB, CONST_CS | CONST_PERSISTENT); 296 297 REGISTER_LONG_CONSTANT("STREAM_SERVER_BIND", STREAM_XPORT_BIND, CONST_CS | CONST_PERSISTENT); 298 REGISTER_LONG_CONSTANT("STREAM_SERVER_LISTEN", STREAM_XPORT_LISTEN, CONST_CS | CONST_PERSISTENT); 299 300 REGISTER_LONG_CONSTANT("FILE_USE_INCLUDE_PATH", PHP_FILE_USE_INCLUDE_PATH, CONST_CS | CONST_PERSISTENT); 301 REGISTER_LONG_CONSTANT("FILE_IGNORE_NEW_LINES", PHP_FILE_IGNORE_NEW_LINES, CONST_CS | CONST_PERSISTENT); 302 REGISTER_LONG_CONSTANT("FILE_SKIP_EMPTY_LINES", PHP_FILE_SKIP_EMPTY_LINES, CONST_CS | CONST_PERSISTENT); 303 REGISTER_LONG_CONSTANT("FILE_APPEND", PHP_FILE_APPEND, CONST_CS | CONST_PERSISTENT); 304 REGISTER_LONG_CONSTANT("FILE_NO_DEFAULT_CONTEXT", PHP_FILE_NO_DEFAULT_CONTEXT, CONST_CS | CONST_PERSISTENT); 305 306 REGISTER_LONG_CONSTANT("FILE_TEXT", 0, CONST_CS | CONST_PERSISTENT); 307 REGISTER_LONG_CONSTANT("FILE_BINARY", 0, CONST_CS | CONST_PERSISTENT); 308 309 #ifdef HAVE_FNMATCH 310 REGISTER_LONG_CONSTANT("FNM_NOESCAPE", FNM_NOESCAPE, CONST_CS | CONST_PERSISTENT); 311 REGISTER_LONG_CONSTANT("FNM_PATHNAME", FNM_PATHNAME, CONST_CS | CONST_PERSISTENT); 312 REGISTER_LONG_CONSTANT("FNM_PERIOD", FNM_PERIOD, CONST_CS | CONST_PERSISTENT); 313 # ifdef FNM_CASEFOLD /* a GNU extension */ /* TODO emulate if not available */ 314 REGISTER_LONG_CONSTANT("FNM_CASEFOLD", FNM_CASEFOLD, CONST_CS | CONST_PERSISTENT); 315 # endif 316 #endif 317 318 return SUCCESS; 319 } 320 /* }}} */ 321 322 PHP_MSHUTDOWN_FUNCTION(file) /* {{{ */ 323 { 324 #ifndef ZTS 325 file_globals_dtor(&file_globals); 326 #endif 327 return SUCCESS; 328 } 329 /* }}} */ 330 331 static int flock_values[] = { LOCK_SH, LOCK_EX, LOCK_UN }; 332 333 /* {{{ proto bool flock(resource fp, int operation [, int &wouldblock]) 334 Portable file locking */ 335 PHP_FUNCTION(flock) 336 { 337 zval *res, *wouldblock = NULL; 338 int act; 339 php_stream *stream; 340 zend_long operation = 0; 341 342 ZEND_PARSE_PARAMETERS_START(2, 3) 343 Z_PARAM_RESOURCE(res) 344 Z_PARAM_LONG(operation) 345 Z_PARAM_OPTIONAL 346 Z_PARAM_ZVAL_DEREF(wouldblock) 347 ZEND_PARSE_PARAMETERS_END(); 348 349 PHP_STREAM_TO_ZVAL(stream, res); 350 351 act = operation & 3; 352 if (act < 1 || act > 3) { 353 php_error_docref(NULL, E_WARNING, "Illegal operation argument"); 354 RETURN_FALSE; 355 } 356 357 if (wouldblock) { 358 zval_ptr_dtor(wouldblock); 359 ZVAL_LONG(wouldblock, 0); 360 } 361 362 /* flock_values contains all possible actions if (operation & 4) we won't block on the lock */ 363 act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0); 364 if (php_stream_lock(stream, act)) { 365 if (operation && errno == EWOULDBLOCK && wouldblock) { 366 ZVAL_LONG(wouldblock, 1); 367 } 368 RETURN_FALSE; 369 } 370 RETURN_TRUE; 371 } 372 /* }}} */ 373 374 #define PHP_META_UNSAFE ".\\+*?[^]$() " 375 376 /* {{{ proto array get_meta_tags(string filename [, bool use_include_path]) 377 Extracts all meta tag content attributes from a file and returns an array */ 378 PHP_FUNCTION(get_meta_tags) 379 { 380 char *filename; 381 size_t filename_len; 382 zend_bool use_include_path = 0; 383 int in_tag = 0, done = 0; 384 int looking_for_val = 0, have_name = 0, have_content = 0; 385 int saw_name = 0, saw_content = 0; 386 char *name = NULL, *value = NULL, *temp = NULL; 387 php_meta_tags_token tok, tok_last; 388 php_meta_tags_data md; 389 390 /* Initiailize our structure */ 391 memset(&md, 0, sizeof(md)); 392 393 /* Parse arguments */ 394 ZEND_PARSE_PARAMETERS_START(1, 2) 395 Z_PARAM_PATH(filename, filename_len) 396 Z_PARAM_OPTIONAL 397 Z_PARAM_BOOL(use_include_path) 398 ZEND_PARSE_PARAMETERS_END(); 399 400 md.stream = php_stream_open_wrapper(filename, "rb", 401 (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, 402 NULL); 403 if (!md.stream) { 404 RETURN_FALSE; 405 } 406 407 array_init(return_value); 408 409 tok_last = TOK_EOF; 410 411 while (!done && (tok = php_next_meta_token(&md)) != TOK_EOF) { 412 if (tok == TOK_ID) { 413 if (tok_last == TOK_OPENTAG) { 414 md.in_meta = !strcasecmp("meta", md.token_data); 415 } else if (tok_last == TOK_SLASH && in_tag) { 416 if (strcasecmp("head", md.token_data) == 0) { 417 /* We are done here! */ 418 done = 1; 419 } 420 } else if (tok_last == TOK_EQUAL && looking_for_val) { 421 if (saw_name) { 422 if (name) efree(name); 423 /* Get the NAME attr (Single word attr, non-quoted) */ 424 temp = name = estrndup(md.token_data, md.token_len); 425 426 while (temp && *temp) { 427 if (strchr(PHP_META_UNSAFE, *temp)) { 428 *temp = '_'; 429 } 430 temp++; 431 } 432 433 have_name = 1; 434 } else if (saw_content) { 435 if (value) efree(value); 436 value = estrndup(md.token_data, md.token_len); 437 have_content = 1; 438 } 439 440 looking_for_val = 0; 441 } else { 442 if (md.in_meta) { 443 if (strcasecmp("name", md.token_data) == 0) { 444 saw_name = 1; 445 saw_content = 0; 446 looking_for_val = 1; 447 } else if (strcasecmp("content", md.token_data) == 0) { 448 saw_name = 0; 449 saw_content = 1; 450 looking_for_val = 1; 451 } 452 } 453 } 454 } else if (tok == TOK_STRING && tok_last == TOK_EQUAL && looking_for_val) { 455 if (saw_name) { 456 if (name) efree(name); 457 /* Get the NAME attr (Quoted single/double) */ 458 temp = name = estrndup(md.token_data, md.token_len); 459 460 while (temp && *temp) { 461 if (strchr(PHP_META_UNSAFE, *temp)) { 462 *temp = '_'; 463 } 464 temp++; 465 } 466 467 have_name = 1; 468 } else if (saw_content) { 469 if (value) efree(value); 470 value = estrndup(md.token_data, md.token_len); 471 have_content = 1; 472 } 473 474 looking_for_val = 0; 475 } else if (tok == TOK_OPENTAG) { 476 if (looking_for_val) { 477 looking_for_val = 0; 478 have_name = saw_name = 0; 479 have_content = saw_content = 0; 480 } 481 in_tag = 1; 482 } else if (tok == TOK_CLOSETAG) { 483 if (have_name) { 484 /* For BC */ 485 php_strtolower(name, strlen(name)); 486 if (have_content) { 487 add_assoc_string(return_value, name, value); 488 } else { 489 add_assoc_string(return_value, name, ""); 490 } 491 492 efree(name); 493 if (value) efree(value); 494 } else if (have_content) { 495 efree(value); 496 } 497 498 name = value = NULL; 499 500 /* Reset all of our flags */ 501 in_tag = looking_for_val = 0; 502 have_name = saw_name = 0; 503 have_content = saw_content = 0; 504 md.in_meta = 0; 505 } 506 507 tok_last = tok; 508 509 if (md.token_data) 510 efree(md.token_data); 511 512 md.token_data = NULL; 513 } 514 515 if (value) efree(value); 516 if (name) efree(name); 517 php_stream_close(md.stream); 518 } 519 /* }}} */ 520 521 /* {{{ proto string file_get_contents(string filename [, bool use_include_path [, resource context [, int offset [, int maxlen]]]]) 522 Read the entire file into a string */ 523 PHP_FUNCTION(file_get_contents) 524 { 525 char *filename; 526 size_t filename_len; 527 zend_bool use_include_path = 0; 528 php_stream *stream; 529 zend_long offset = 0; 530 zend_long maxlen = (ssize_t) PHP_STREAM_COPY_ALL; 531 zval *zcontext = NULL; 532 php_stream_context *context = NULL; 533 zend_string *contents; 534 535 /* Parse arguments */ 536 ZEND_PARSE_PARAMETERS_START(1, 5) 537 Z_PARAM_PATH(filename, filename_len) 538 Z_PARAM_OPTIONAL 539 Z_PARAM_BOOL(use_include_path) 540 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 541 Z_PARAM_LONG(offset) 542 Z_PARAM_LONG(maxlen) 543 ZEND_PARSE_PARAMETERS_END(); 544 545 if (ZEND_NUM_ARGS() == 5 && maxlen < 0) { 546 php_error_docref(NULL, E_WARNING, "length must be greater than or equal to zero"); 547 RETURN_FALSE; 548 } 549 550 context = php_stream_context_from_zval(zcontext, 0); 551 552 stream = php_stream_open_wrapper_ex(filename, "rb", 553 (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, 554 NULL, context); 555 if (!stream) { 556 RETURN_FALSE; 557 } 558 559 if (offset != 0 && php_stream_seek(stream, offset, ((offset > 0) ? SEEK_SET : SEEK_END)) < 0) { 560 php_error_docref(NULL, E_WARNING, "Failed to seek to position " ZEND_LONG_FMT " in the stream", offset); 561 php_stream_close(stream); 562 RETURN_FALSE; 563 } 564 565 if (maxlen > INT_MAX) { 566 php_error_docref(NULL, E_WARNING, "maxlen truncated from " ZEND_LONG_FMT " to %d bytes", maxlen, INT_MAX); 567 maxlen = INT_MAX; 568 } 569 if ((contents = php_stream_copy_to_mem(stream, maxlen, 0)) != NULL) { 570 RETVAL_STR(contents); 571 } else { 572 RETVAL_EMPTY_STRING(); 573 } 574 575 php_stream_close(stream); 576 } 577 /* }}} */ 578 579 /* {{{ proto int file_put_contents(string file, mixed data [, int flags [, resource context]]) 580 Write/Create a file with contents data and return the number of bytes written */ 581 PHP_FUNCTION(file_put_contents) 582 { 583 php_stream *stream; 584 char *filename; 585 size_t filename_len; 586 zval *data; 587 size_t numbytes = 0; 588 zend_long flags = 0; 589 zval *zcontext = NULL; 590 php_stream_context *context = NULL; 591 php_stream *srcstream = NULL; 592 char mode[3] = "wb"; 593 594 ZEND_PARSE_PARAMETERS_START(2, 4) 595 Z_PARAM_PATH(filename, filename_len) 596 Z_PARAM_ZVAL(data) 597 Z_PARAM_OPTIONAL 598 Z_PARAM_LONG(flags) 599 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 600 ZEND_PARSE_PARAMETERS_END(); 601 602 if (Z_TYPE_P(data) == IS_RESOURCE) { 603 php_stream_from_zval(srcstream, data); 604 } 605 606 context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT); 607 608 if (flags & PHP_FILE_APPEND) { 609 mode[0] = 'a'; 610 } else if (flags & LOCK_EX) { 611 /* check to make sure we are dealing with a regular file */ 612 if (php_memnstr(filename, "://", sizeof("://") - 1, filename + filename_len)) { 613 if (strncasecmp(filename, "file://", sizeof("file://") - 1)) { 614 php_error_docref(NULL, E_WARNING, "Exclusive locks may only be set for regular files"); 615 RETURN_FALSE; 616 } 617 } 618 mode[0] = 'c'; 619 } 620 mode[2] = '\0'; 621 622 stream = php_stream_open_wrapper_ex(filename, mode, ((flags & PHP_FILE_USE_INCLUDE_PATH) ? USE_PATH : 0) | REPORT_ERRORS, NULL, context); 623 if (stream == NULL) { 624 RETURN_FALSE; 625 } 626 627 if (flags & LOCK_EX && (!php_stream_supports_lock(stream) || php_stream_lock(stream, LOCK_EX))) { 628 php_stream_close(stream); 629 php_error_docref(NULL, E_WARNING, "Exclusive locks are not supported for this stream"); 630 RETURN_FALSE; 631 } 632 633 if (mode[0] == 'c') { 634 php_stream_truncate_set_size(stream, 0); 635 } 636 637 switch (Z_TYPE_P(data)) { 638 case IS_RESOURCE: { 639 size_t len; 640 if (php_stream_copy_to_stream_ex(srcstream, stream, PHP_STREAM_COPY_ALL, &len) != SUCCESS) { 641 numbytes = -1; 642 } else { 643 if (len > ZEND_LONG_MAX) { 644 php_error_docref(NULL, E_WARNING, "content truncated from %zu to " ZEND_LONG_FMT " bytes", len, ZEND_LONG_MAX); 645 len = ZEND_LONG_MAX; 646 } 647 numbytes = len; 648 } 649 break; 650 } 651 case IS_NULL: 652 case IS_LONG: 653 case IS_DOUBLE: 654 case IS_FALSE: 655 case IS_TRUE: 656 convert_to_string_ex(data); 657 658 case IS_STRING: 659 if (Z_STRLEN_P(data)) { 660 numbytes = php_stream_write(stream, Z_STRVAL_P(data), Z_STRLEN_P(data)); 661 if (numbytes != Z_STRLEN_P(data)) { 662 php_error_docref(NULL, E_WARNING, "Only "ZEND_LONG_FMT" of %zd bytes written, possibly out of free disk space", numbytes, Z_STRLEN_P(data)); 663 numbytes = -1; 664 } 665 } 666 break; 667 668 case IS_ARRAY: 669 if (zend_hash_num_elements(Z_ARRVAL_P(data))) { 670 size_t bytes_written; 671 zval *tmp; 672 673 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(data), tmp) { 674 zend_string *t; 675 zend_string *str = zval_get_tmp_string(tmp, &t); 676 if (ZSTR_LEN(str)) { 677 numbytes += ZSTR_LEN(str); 678 bytes_written = php_stream_write(stream, ZSTR_VAL(str), ZSTR_LEN(str)); 679 if (bytes_written != ZSTR_LEN(str)) { 680 php_error_docref(NULL, E_WARNING, "Failed to write %zd bytes to %s", ZSTR_LEN(str), filename); 681 zend_tmp_string_release(t); 682 numbytes = -1; 683 break; 684 } 685 } 686 zend_tmp_string_release(t); 687 } ZEND_HASH_FOREACH_END(); 688 } 689 break; 690 691 case IS_OBJECT: 692 if (Z_OBJ_HT_P(data) != NULL) { 693 zval out; 694 695 if (zend_std_cast_object_tostring(data, &out, IS_STRING) == SUCCESS) { 696 numbytes = php_stream_write(stream, Z_STRVAL(out), Z_STRLEN(out)); 697 if (numbytes != Z_STRLEN(out)) { 698 php_error_docref(NULL, E_WARNING, "Only "ZEND_LONG_FMT" of %zd bytes written, possibly out of free disk space", numbytes, Z_STRLEN(out)); 699 numbytes = -1; 700 } 701 zval_ptr_dtor_str(&out); 702 break; 703 } 704 } 705 default: 706 numbytes = -1; 707 break; 708 } 709 php_stream_close(stream); 710 711 if (numbytes == (size_t)-1) { 712 RETURN_FALSE; 713 } 714 715 RETURN_LONG(numbytes); 716 } 717 /* }}} */ 718 719 #define PHP_FILE_BUF_SIZE 80 720 721 /* {{{ proto array file(string filename [, int flags[, resource context]]) 722 Read entire file into an array */ 723 PHP_FUNCTION(file) 724 { 725 char *filename; 726 size_t filename_len; 727 char *p, *s, *e; 728 register int i = 0; 729 char eol_marker = '\n'; 730 zend_long flags = 0; 731 zend_bool use_include_path; 732 zend_bool include_new_line; 733 zend_bool skip_blank_lines; 734 php_stream *stream; 735 zval *zcontext = NULL; 736 php_stream_context *context = NULL; 737 zend_string *target_buf; 738 739 /* Parse arguments */ 740 ZEND_PARSE_PARAMETERS_START(1, 3) 741 Z_PARAM_PATH(filename, filename_len) 742 Z_PARAM_OPTIONAL 743 Z_PARAM_LONG(flags) 744 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 745 ZEND_PARSE_PARAMETERS_END(); 746 747 if (flags < 0 || flags > (PHP_FILE_USE_INCLUDE_PATH | PHP_FILE_IGNORE_NEW_LINES | PHP_FILE_SKIP_EMPTY_LINES | PHP_FILE_NO_DEFAULT_CONTEXT)) { 748 php_error_docref(NULL, E_WARNING, "'" ZEND_LONG_FMT "' flag is not supported", flags); 749 RETURN_FALSE; 750 } 751 752 use_include_path = flags & PHP_FILE_USE_INCLUDE_PATH; 753 include_new_line = !(flags & PHP_FILE_IGNORE_NEW_LINES); 754 skip_blank_lines = flags & PHP_FILE_SKIP_EMPTY_LINES; 755 756 context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT); 757 758 stream = php_stream_open_wrapper_ex(filename, "rb", (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, context); 759 if (!stream) { 760 RETURN_FALSE; 761 } 762 763 /* Initialize return array */ 764 array_init(return_value); 765 766 if ((target_buf = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0)) != NULL) { 767 s = ZSTR_VAL(target_buf); 768 e = ZSTR_VAL(target_buf) + ZSTR_LEN(target_buf); 769 770 if (!(p = (char*)php_stream_locate_eol(stream, target_buf))) { 771 p = e; 772 goto parse_eol; 773 } 774 775 if (stream->flags & PHP_STREAM_FLAG_EOL_MAC) { 776 eol_marker = '\r'; 777 } 778 779 /* for performance reasons the code is duplicated, so that the if (include_new_line) 780 * will not need to be done for every single line in the file. */ 781 if (include_new_line) { 782 do { 783 p++; 784 parse_eol: 785 add_index_stringl(return_value, i++, s, p-s); 786 s = p; 787 } while ((p = memchr(p, eol_marker, (e-p)))); 788 } else { 789 do { 790 int windows_eol = 0; 791 if (p != ZSTR_VAL(target_buf) && eol_marker == '\n' && *(p - 1) == '\r') { 792 windows_eol++; 793 } 794 if (skip_blank_lines && !(p-s-windows_eol)) { 795 s = ++p; 796 continue; 797 } 798 add_index_stringl(return_value, i++, s, p-s-windows_eol); 799 s = ++p; 800 } while ((p = memchr(p, eol_marker, (e-p)))); 801 } 802 803 /* handle any left overs of files without new lines */ 804 if (s != e) { 805 p = e; 806 goto parse_eol; 807 } 808 } 809 810 if (target_buf) { 811 zend_string_free(target_buf); 812 } 813 php_stream_close(stream); 814 } 815 /* }}} */ 816 817 /* {{{ proto string tempnam(string dir, string prefix) 818 Create a unique filename in a directory */ 819 PHP_FUNCTION(tempnam) 820 { 821 char *dir, *prefix; 822 size_t dir_len, prefix_len; 823 zend_string *opened_path; 824 int fd; 825 zend_string *p; 826 827 ZEND_PARSE_PARAMETERS_START(2, 2) 828 Z_PARAM_PATH(dir, dir_len) 829 Z_PARAM_PATH(prefix, prefix_len) 830 ZEND_PARSE_PARAMETERS_END(); 831 832 if (php_check_open_basedir(dir)) { 833 RETURN_FALSE; 834 } 835 836 p = php_basename(prefix, prefix_len, NULL, 0); 837 if (ZSTR_LEN(p) > 64) { 838 ZSTR_VAL(p)[63] = '\0'; 839 } 840 841 RETVAL_FALSE; 842 843 if ((fd = php_open_temporary_fd_ex(dir, ZSTR_VAL(p), &opened_path, 1)) >= 0) { 844 close(fd); 845 RETVAL_STR(opened_path); 846 } 847 zend_string_release_ex(p, 0); 848 } 849 /* }}} */ 850 851 /* {{{ proto resource tmpfile(void) 852 Create a temporary file that will be deleted automatically after use */ 853 PHP_NAMED_FUNCTION(php_if_tmpfile) 854 { 855 php_stream *stream; 856 857 if (zend_parse_parameters_none() == FAILURE) { 858 return; 859 } 860 861 stream = php_stream_fopen_tmpfile(); 862 863 if (stream) { 864 php_stream_to_zval(stream, return_value); 865 } else { 866 RETURN_FALSE; 867 } 868 } 869 /* }}} */ 870 871 /* {{{ proto resource fopen(string filename, string mode [, bool use_include_path [, resource context]]) 872 Open a file or a URL and return a file pointer */ 873 PHP_NAMED_FUNCTION(php_if_fopen) 874 { 875 char *filename, *mode; 876 size_t filename_len, mode_len; 877 zend_bool use_include_path = 0; 878 zval *zcontext = NULL; 879 php_stream *stream; 880 php_stream_context *context = NULL; 881 882 ZEND_PARSE_PARAMETERS_START(2, 4) 883 Z_PARAM_PATH(filename, filename_len) 884 Z_PARAM_STRING(mode, mode_len) 885 Z_PARAM_OPTIONAL 886 Z_PARAM_BOOL(use_include_path) 887 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 888 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 889 890 context = php_stream_context_from_zval(zcontext, 0); 891 892 stream = php_stream_open_wrapper_ex(filename, mode, (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, context); 893 894 if (stream == NULL) { 895 RETURN_FALSE; 896 } 897 898 php_stream_to_zval(stream, return_value); 899 } 900 /* }}} */ 901 902 /* {{{ proto bool fclose(resource fp) 903 Close an open file pointer */ 904 PHPAPI PHP_FUNCTION(fclose) 905 { 906 zval *res; 907 php_stream *stream; 908 909 ZEND_PARSE_PARAMETERS_START(1, 1) 910 Z_PARAM_RESOURCE(res) 911 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 912 913 PHP_STREAM_TO_ZVAL(stream, res); 914 915 if ((stream->flags & PHP_STREAM_FLAG_NO_FCLOSE) != 0) { 916 php_error_docref(NULL, E_WARNING, "%d is not a valid stream resource", stream->res->handle); 917 RETURN_FALSE; 918 } 919 920 php_stream_free(stream, 921 PHP_STREAM_FREE_KEEP_RSRC | 922 (stream->is_persistent ? PHP_STREAM_FREE_CLOSE_PERSISTENT : PHP_STREAM_FREE_CLOSE)); 923 924 RETURN_TRUE; 925 } 926 /* }}} */ 927 928 /* {{{ proto resource popen(string command, string mode) 929 Execute a command and open either a read or a write pipe to it */ 930 PHP_FUNCTION(popen) 931 { 932 char *command, *mode; 933 size_t command_len, mode_len; 934 FILE *fp; 935 php_stream *stream; 936 char *posix_mode; 937 938 ZEND_PARSE_PARAMETERS_START(2, 2) 939 Z_PARAM_PATH(command, command_len) 940 Z_PARAM_STRING(mode, mode_len) 941 ZEND_PARSE_PARAMETERS_END(); 942 943 posix_mode = estrndup(mode, mode_len); 944 #ifndef PHP_WIN32 945 { 946 char *z = memchr(posix_mode, 'b', mode_len); 947 if (z) { 948 memmove(z, z + 1, mode_len - (z - posix_mode)); 949 } 950 } 951 #endif 952 953 fp = VCWD_POPEN(command, posix_mode); 954 if (!fp) { 955 php_error_docref2(NULL, command, posix_mode, E_WARNING, "%s", strerror(errno)); 956 efree(posix_mode); 957 RETURN_FALSE; 958 } 959 960 stream = php_stream_fopen_from_pipe(fp, mode); 961 962 if (stream == NULL) { 963 php_error_docref2(NULL, command, mode, E_WARNING, "%s", strerror(errno)); 964 RETVAL_FALSE; 965 } else { 966 php_stream_to_zval(stream, return_value); 967 } 968 969 efree(posix_mode); 970 } 971 /* }}} */ 972 973 /* {{{ proto int pclose(resource fp) 974 Close a file pointer opened by popen() */ 975 PHP_FUNCTION(pclose) 976 { 977 zval *res; 978 php_stream *stream; 979 980 ZEND_PARSE_PARAMETERS_START(1, 1) 981 Z_PARAM_RESOURCE(res) 982 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 983 984 PHP_STREAM_TO_ZVAL(stream, res); 985 986 FG(pclose_wait) = 1; 987 zend_list_close(stream->res); 988 FG(pclose_wait) = 0; 989 RETURN_LONG(FG(pclose_ret)); 990 } 991 /* }}} */ 992 993 /* {{{ proto bool feof(resource fp) 994 Test for end-of-file on a file pointer */ 995 PHPAPI PHP_FUNCTION(feof) 996 { 997 zval *res; 998 php_stream *stream; 999 1000 ZEND_PARSE_PARAMETERS_START(1, 1) 1001 Z_PARAM_RESOURCE(res) 1002 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1003 1004 PHP_STREAM_TO_ZVAL(stream, res); 1005 1006 if (php_stream_eof(stream)) { 1007 RETURN_TRUE; 1008 } else { 1009 RETURN_FALSE; 1010 } 1011 } 1012 /* }}} */ 1013 1014 /* {{{ proto string fgets(resource fp[, int length]) 1015 Get a line from file pointer */ 1016 PHPAPI PHP_FUNCTION(fgets) 1017 { 1018 zval *res; 1019 zend_long len = 1024; 1020 char *buf = NULL; 1021 int argc = ZEND_NUM_ARGS(); 1022 size_t line_len = 0; 1023 zend_string *str; 1024 php_stream *stream; 1025 1026 ZEND_PARSE_PARAMETERS_START(1, 2) 1027 Z_PARAM_RESOURCE(res) 1028 Z_PARAM_OPTIONAL 1029 Z_PARAM_LONG(len) 1030 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1031 1032 PHP_STREAM_TO_ZVAL(stream, res); 1033 1034 if (argc == 1) { 1035 /* ask streams to give us a buffer of an appropriate size */ 1036 buf = php_stream_get_line(stream, NULL, 0, &line_len); 1037 if (buf == NULL) { 1038 RETURN_FALSE; 1039 } 1040 // TODO: avoid reallocation ??? 1041 RETVAL_STRINGL(buf, line_len); 1042 efree(buf); 1043 } else if (argc > 1) { 1044 if (len <= 0) { 1045 php_error_docref(NULL, E_WARNING, "Length parameter must be greater than 0"); 1046 RETURN_FALSE; 1047 } 1048 1049 str = zend_string_alloc(len, 0); 1050 if (php_stream_get_line(stream, ZSTR_VAL(str), len, &line_len) == NULL) { 1051 zend_string_efree(str); 1052 RETURN_FALSE; 1053 } 1054 /* resize buffer if it's much larger than the result. 1055 * Only needed if the user requested a buffer size. */ 1056 if (line_len < (size_t)len / 2) { 1057 str = zend_string_truncate(str, line_len, 0); 1058 } else { 1059 ZSTR_LEN(str) = line_len; 1060 } 1061 RETURN_NEW_STR(str); 1062 } 1063 } 1064 /* }}} */ 1065 1066 /* {{{ proto string fgetc(resource fp) 1067 Get a character from file pointer */ 1068 PHPAPI PHP_FUNCTION(fgetc) 1069 { 1070 zval *res; 1071 char buf[2]; 1072 int result; 1073 php_stream *stream; 1074 1075 ZEND_PARSE_PARAMETERS_START(1, 1) 1076 Z_PARAM_RESOURCE(res) 1077 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1078 1079 PHP_STREAM_TO_ZVAL(stream, res); 1080 1081 result = php_stream_getc(stream); 1082 1083 if (result == EOF) { 1084 RETVAL_FALSE; 1085 } else { 1086 buf[0] = result; 1087 buf[1] = '\0'; 1088 1089 RETURN_STRINGL(buf, 1); 1090 } 1091 } 1092 /* }}} */ 1093 1094 /* {{{ proto string fgetss(resource fp [, int length [, string allowable_tags]]) 1095 Get a line from file pointer and strip HTML tags */ 1096 PHPAPI PHP_FUNCTION(fgetss) 1097 { 1098 zval *fd; 1099 zend_long bytes = 0; 1100 size_t len = 0; 1101 size_t actual_len, retval_len; 1102 char *buf = NULL, *retval; 1103 php_stream *stream; 1104 char *allowed_tags=NULL; 1105 size_t allowed_tags_len=0; 1106 1107 ZEND_PARSE_PARAMETERS_START(1, 3) 1108 Z_PARAM_RESOURCE(fd) 1109 Z_PARAM_OPTIONAL 1110 Z_PARAM_LONG(bytes) 1111 Z_PARAM_STRING(allowed_tags, allowed_tags_len) 1112 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1113 1114 PHP_STREAM_TO_ZVAL(stream, fd); 1115 1116 if (ZEND_NUM_ARGS() >= 2) { 1117 if (bytes <= 0) { 1118 php_error_docref(NULL, E_WARNING, "Length parameter must be greater than 0"); 1119 RETURN_FALSE; 1120 } 1121 1122 len = (size_t) bytes; 1123 buf = safe_emalloc(sizeof(char), (len + 1), 0); 1124 /*needed because recv doesn't set null char at end*/ 1125 memset(buf, 0, len + 1); 1126 } 1127 1128 if ((retval = php_stream_get_line(stream, buf, len, &actual_len)) == NULL) { 1129 if (buf != NULL) { 1130 efree(buf); 1131 } 1132 RETURN_FALSE; 1133 } 1134 1135 retval_len = php_strip_tags(retval, actual_len, &stream->fgetss_state, allowed_tags, allowed_tags_len); 1136 1137 // TODO: avoid reallocation ??? 1138 RETVAL_STRINGL(retval, retval_len); 1139 efree(retval); 1140 } 1141 /* }}} */ 1142 1143 /* {{{ proto mixed fscanf(resource stream, string format [, string ...]) 1144 Implements a mostly ANSI compatible fscanf() */ 1145 PHP_FUNCTION(fscanf) 1146 { 1147 int result, argc = 0; 1148 size_t format_len; 1149 zval *args = NULL; 1150 zval *file_handle; 1151 char *buf, *format; 1152 size_t len; 1153 void *what; 1154 1155 ZEND_PARSE_PARAMETERS_START(2, -1) 1156 Z_PARAM_RESOURCE(file_handle) 1157 Z_PARAM_STRING(format, format_len) 1158 Z_PARAM_VARIADIC('*', args, argc) 1159 ZEND_PARSE_PARAMETERS_END(); 1160 1161 what = zend_fetch_resource2(Z_RES_P(file_handle), "File-Handle", php_file_le_stream(), php_file_le_pstream()); 1162 1163 /* we can't do a ZEND_VERIFY_RESOURCE(what), otherwise we end up 1164 * with a leak if we have an invalid filehandle. This needs changing 1165 * if the code behind ZEND_VERIFY_RESOURCE changed. - cc */ 1166 if (!what) { 1167 RETURN_FALSE; 1168 } 1169 1170 buf = php_stream_get_line((php_stream *) what, NULL, 0, &len); 1171 if (buf == NULL) { 1172 RETURN_FALSE; 1173 } 1174 1175 result = php_sscanf_internal(buf, format, argc, args, 0, return_value); 1176 1177 efree(buf); 1178 1179 if (SCAN_ERROR_WRONG_PARAM_COUNT == result) { 1180 WRONG_PARAM_COUNT; 1181 } 1182 } 1183 /* }}} */ 1184 1185 /* {{{ proto int fwrite(resource fp, string str [, int length]) 1186 Binary-safe file write */ 1187 PHPAPI PHP_FUNCTION(fwrite) 1188 { 1189 zval *res; 1190 char *input; 1191 size_t inputlen; 1192 size_t ret; 1193 size_t num_bytes; 1194 zend_long maxlen = 0; 1195 php_stream *stream; 1196 1197 ZEND_PARSE_PARAMETERS_START(2, 3) 1198 Z_PARAM_RESOURCE(res) 1199 Z_PARAM_STRING(input, inputlen) 1200 Z_PARAM_OPTIONAL 1201 Z_PARAM_LONG(maxlen) 1202 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1203 1204 if (ZEND_NUM_ARGS() == 2) { 1205 num_bytes = inputlen; 1206 } else if (maxlen <= 0) { 1207 num_bytes = 0; 1208 } else { 1209 num_bytes = MIN((size_t) maxlen, inputlen); 1210 } 1211 1212 if (!num_bytes) { 1213 RETURN_LONG(0); 1214 } 1215 1216 PHP_STREAM_TO_ZVAL(stream, res); 1217 1218 ret = php_stream_write(stream, input, num_bytes); 1219 1220 RETURN_LONG(ret); 1221 } 1222 /* }}} */ 1223 1224 /* {{{ proto bool fflush(resource fp) 1225 Flushes output */ 1226 PHPAPI PHP_FUNCTION(fflush) 1227 { 1228 zval *res; 1229 int ret; 1230 php_stream *stream; 1231 1232 ZEND_PARSE_PARAMETERS_START(1, 1) 1233 Z_PARAM_RESOURCE(res) 1234 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1235 1236 PHP_STREAM_TO_ZVAL(stream, res); 1237 1238 ret = php_stream_flush(stream); 1239 if (ret) { 1240 RETURN_FALSE; 1241 } 1242 RETURN_TRUE; 1243 } 1244 /* }}} */ 1245 1246 /* {{{ proto bool rewind(resource fp) 1247 Rewind the position of a file pointer */ 1248 PHPAPI PHP_FUNCTION(rewind) 1249 { 1250 zval *res; 1251 php_stream *stream; 1252 1253 ZEND_PARSE_PARAMETERS_START(1, 1) 1254 Z_PARAM_RESOURCE(res) 1255 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1256 1257 PHP_STREAM_TO_ZVAL(stream, res); 1258 1259 if (-1 == php_stream_rewind(stream)) { 1260 RETURN_FALSE; 1261 } 1262 RETURN_TRUE; 1263 } 1264 /* }}} */ 1265 1266 /* {{{ proto int ftell(resource fp) 1267 Get file pointer's read/write position */ 1268 PHPAPI PHP_FUNCTION(ftell) 1269 { 1270 zval *res; 1271 zend_long ret; 1272 php_stream *stream; 1273 1274 ZEND_PARSE_PARAMETERS_START(1, 1) 1275 Z_PARAM_RESOURCE(res) 1276 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1277 1278 PHP_STREAM_TO_ZVAL(stream, res); 1279 1280 ret = php_stream_tell(stream); 1281 if (ret == -1) { 1282 RETURN_FALSE; 1283 } 1284 RETURN_LONG(ret); 1285 } 1286 /* }}} */ 1287 1288 /* {{{ proto int fseek(resource fp, int offset [, int whence]) 1289 Seek on a file pointer */ 1290 PHPAPI PHP_FUNCTION(fseek) 1291 { 1292 zval *res; 1293 zend_long offset, whence = SEEK_SET; 1294 php_stream *stream; 1295 1296 ZEND_PARSE_PARAMETERS_START(2, 3) 1297 Z_PARAM_RESOURCE(res) 1298 Z_PARAM_LONG(offset) 1299 Z_PARAM_OPTIONAL 1300 Z_PARAM_LONG(whence) 1301 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1302 1303 PHP_STREAM_TO_ZVAL(stream, res); 1304 1305 RETURN_LONG(php_stream_seek(stream, offset, (int) whence)); 1306 } 1307 /* }}} */ 1308 1309 /* {{{ php_mkdir 1310 */ 1311 1312 /* DEPRECATED APIs: Use php_stream_mkdir() instead */ 1313 PHPAPI int php_mkdir_ex(const char *dir, zend_long mode, int options) 1314 { 1315 int ret; 1316 1317 if (php_check_open_basedir(dir)) { 1318 return -1; 1319 } 1320 1321 if ((ret = VCWD_MKDIR(dir, (mode_t)mode)) < 0 && (options & REPORT_ERRORS)) { 1322 php_error_docref(NULL, E_WARNING, "%s", strerror(errno)); 1323 } 1324 1325 return ret; 1326 } 1327 1328 PHPAPI int php_mkdir(const char *dir, zend_long mode) 1329 { 1330 return php_mkdir_ex(dir, mode, REPORT_ERRORS); 1331 } 1332 /* }}} */ 1333 1334 /* {{{ proto bool mkdir(string pathname [, int mode [, bool recursive [, resource context]]]) 1335 Create a directory */ 1336 PHP_FUNCTION(mkdir) 1337 { 1338 char *dir; 1339 size_t dir_len; 1340 zval *zcontext = NULL; 1341 zend_long mode = 0777; 1342 zend_bool recursive = 0; 1343 php_stream_context *context; 1344 1345 ZEND_PARSE_PARAMETERS_START(1, 4) 1346 Z_PARAM_PATH(dir, dir_len) 1347 Z_PARAM_OPTIONAL 1348 Z_PARAM_LONG(mode) 1349 Z_PARAM_BOOL(recursive) 1350 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 1351 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1352 1353 context = php_stream_context_from_zval(zcontext, 0); 1354 1355 RETURN_BOOL(php_stream_mkdir(dir, (int)mode, (recursive ? PHP_STREAM_MKDIR_RECURSIVE : 0) | REPORT_ERRORS, context)); 1356 } 1357 /* }}} */ 1358 1359 /* {{{ proto bool rmdir(string dirname[, resource context]) 1360 Remove a directory */ 1361 PHP_FUNCTION(rmdir) 1362 { 1363 char *dir; 1364 size_t dir_len; 1365 zval *zcontext = NULL; 1366 php_stream_context *context; 1367 1368 ZEND_PARSE_PARAMETERS_START(1, 2) 1369 Z_PARAM_PATH(dir, dir_len) 1370 Z_PARAM_OPTIONAL 1371 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 1372 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1373 1374 context = php_stream_context_from_zval(zcontext, 0); 1375 1376 RETURN_BOOL(php_stream_rmdir(dir, REPORT_ERRORS, context)); 1377 } 1378 /* }}} */ 1379 1380 /* {{{ proto int readfile(string filename [, bool use_include_path[, resource context]]) 1381 Output a file or a URL */ 1382 PHP_FUNCTION(readfile) 1383 { 1384 char *filename; 1385 size_t filename_len; 1386 size_t size = 0; 1387 zend_bool use_include_path = 0; 1388 zval *zcontext = NULL; 1389 php_stream *stream; 1390 php_stream_context *context = NULL; 1391 1392 ZEND_PARSE_PARAMETERS_START(1, 3) 1393 Z_PARAM_PATH(filename, filename_len) 1394 Z_PARAM_OPTIONAL 1395 Z_PARAM_BOOL(use_include_path) 1396 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 1397 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1398 1399 context = php_stream_context_from_zval(zcontext, 0); 1400 1401 stream = php_stream_open_wrapper_ex(filename, "rb", (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, context); 1402 if (stream) { 1403 size = php_stream_passthru(stream); 1404 php_stream_close(stream); 1405 RETURN_LONG(size); 1406 } 1407 1408 RETURN_FALSE; 1409 } 1410 /* }}} */ 1411 1412 /* {{{ proto int umask([int mask]) 1413 Return or change the umask */ 1414 PHP_FUNCTION(umask) 1415 { 1416 zend_long mask = 0; 1417 int oldumask; 1418 1419 oldumask = umask(077); 1420 1421 if (BG(umask) == -1) { 1422 BG(umask) = oldumask; 1423 } 1424 1425 ZEND_PARSE_PARAMETERS_START(0, 1) 1426 Z_PARAM_OPTIONAL 1427 Z_PARAM_LONG(mask) 1428 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1429 1430 if (ZEND_NUM_ARGS() == 0) { 1431 umask(oldumask); 1432 } else { 1433 umask((int) mask); 1434 } 1435 1436 RETURN_LONG(oldumask); 1437 } 1438 /* }}} */ 1439 1440 /* {{{ proto int fpassthru(resource fp) 1441 Output all remaining data from a file pointer */ 1442 PHPAPI PHP_FUNCTION(fpassthru) 1443 { 1444 zval *res; 1445 size_t size; 1446 php_stream *stream; 1447 1448 ZEND_PARSE_PARAMETERS_START(1, 1) 1449 Z_PARAM_RESOURCE(res) 1450 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1451 1452 PHP_STREAM_TO_ZVAL(stream, res); 1453 1454 size = php_stream_passthru(stream); 1455 RETURN_LONG(size); 1456 } 1457 /* }}} */ 1458 1459 /* {{{ proto bool rename(string old_name, string new_name[, resource context]) 1460 Rename a file */ 1461 PHP_FUNCTION(rename) 1462 { 1463 char *old_name, *new_name; 1464 size_t old_name_len, new_name_len; 1465 zval *zcontext = NULL; 1466 php_stream_wrapper *wrapper; 1467 php_stream_context *context; 1468 1469 ZEND_PARSE_PARAMETERS_START(2, 3) 1470 Z_PARAM_PATH(old_name, old_name_len) 1471 Z_PARAM_PATH(new_name, new_name_len) 1472 Z_PARAM_OPTIONAL 1473 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 1474 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1475 1476 wrapper = php_stream_locate_url_wrapper(old_name, NULL, 0); 1477 1478 if (!wrapper || !wrapper->wops) { 1479 php_error_docref(NULL, E_WARNING, "Unable to locate stream wrapper"); 1480 RETURN_FALSE; 1481 } 1482 1483 if (!wrapper->wops->rename) { 1484 php_error_docref(NULL, E_WARNING, "%s wrapper does not support renaming", wrapper->wops->label ? wrapper->wops->label : "Source"); 1485 RETURN_FALSE; 1486 } 1487 1488 if (wrapper != php_stream_locate_url_wrapper(new_name, NULL, 0)) { 1489 php_error_docref(NULL, E_WARNING, "Cannot rename a file across wrapper types"); 1490 RETURN_FALSE; 1491 } 1492 1493 context = php_stream_context_from_zval(zcontext, 0); 1494 1495 RETURN_BOOL(wrapper->wops->rename(wrapper, old_name, new_name, 0, context)); 1496 } 1497 /* }}} */ 1498 1499 /* {{{ proto bool unlink(string filename[, context context]) 1500 Delete a file */ 1501 PHP_FUNCTION(unlink) 1502 { 1503 char *filename; 1504 size_t filename_len; 1505 php_stream_wrapper *wrapper; 1506 zval *zcontext = NULL; 1507 php_stream_context *context = NULL; 1508 1509 ZEND_PARSE_PARAMETERS_START(1, 2) 1510 Z_PARAM_PATH(filename, filename_len) 1511 Z_PARAM_OPTIONAL 1512 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 1513 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1514 1515 context = php_stream_context_from_zval(zcontext, 0); 1516 1517 wrapper = php_stream_locate_url_wrapper(filename, NULL, 0); 1518 1519 if (!wrapper || !wrapper->wops) { 1520 php_error_docref(NULL, E_WARNING, "Unable to locate stream wrapper"); 1521 RETURN_FALSE; 1522 } 1523 1524 if (!wrapper->wops->unlink) { 1525 php_error_docref(NULL, E_WARNING, "%s does not allow unlinking", wrapper->wops->label ? wrapper->wops->label : "Wrapper"); 1526 RETURN_FALSE; 1527 } 1528 RETURN_BOOL(wrapper->wops->unlink(wrapper, filename, REPORT_ERRORS, context)); 1529 } 1530 /* }}} */ 1531 1532 /* {{{ proto bool ftruncate(resource fp, int size) 1533 Truncate file to 'size' length */ 1534 PHP_NAMED_FUNCTION(php_if_ftruncate) 1535 { 1536 zval *fp; 1537 zend_long size; 1538 php_stream *stream; 1539 1540 ZEND_PARSE_PARAMETERS_START(2, 2) 1541 Z_PARAM_RESOURCE(fp) 1542 Z_PARAM_LONG(size) 1543 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1544 1545 if (size < 0) { 1546 php_error_docref(NULL, E_WARNING, "Negative size is not supported"); 1547 RETURN_FALSE; 1548 } 1549 1550 PHP_STREAM_TO_ZVAL(stream, fp); 1551 1552 if (!php_stream_truncate_supported(stream)) { 1553 php_error_docref(NULL, E_WARNING, "Can't truncate this stream!"); 1554 RETURN_FALSE; 1555 } 1556 1557 RETURN_BOOL(0 == php_stream_truncate_set_size(stream, size)); 1558 } 1559 /* }}} */ 1560 1561 /* {{{ proto array fstat(resource fp) 1562 Stat() on a filehandle */ 1563 PHP_NAMED_FUNCTION(php_if_fstat) 1564 { 1565 zval *fp; 1566 zval stat_dev, stat_ino, stat_mode, stat_nlink, stat_uid, stat_gid, stat_rdev, 1567 stat_size, stat_atime, stat_mtime, stat_ctime, stat_blksize, stat_blocks; 1568 php_stream *stream; 1569 php_stream_statbuf stat_ssb; 1570 char *stat_sb_names[13] = { 1571 "dev", "ino", "mode", "nlink", "uid", "gid", "rdev", 1572 "size", "atime", "mtime", "ctime", "blksize", "blocks" 1573 }; 1574 1575 ZEND_PARSE_PARAMETERS_START(1, 1) 1576 Z_PARAM_RESOURCE(fp) 1577 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1578 1579 PHP_STREAM_TO_ZVAL(stream, fp); 1580 1581 if (php_stream_stat(stream, &stat_ssb)) { 1582 RETURN_FALSE; 1583 } 1584 1585 array_init(return_value); 1586 1587 ZVAL_LONG(&stat_dev, stat_ssb.sb.st_dev); 1588 ZVAL_LONG(&stat_ino, stat_ssb.sb.st_ino); 1589 ZVAL_LONG(&stat_mode, stat_ssb.sb.st_mode); 1590 ZVAL_LONG(&stat_nlink, stat_ssb.sb.st_nlink); 1591 ZVAL_LONG(&stat_uid, stat_ssb.sb.st_uid); 1592 ZVAL_LONG(&stat_gid, stat_ssb.sb.st_gid); 1593 #ifdef HAVE_STRUCT_STAT_ST_RDEV 1594 # ifdef PHP_WIN32 1595 /* It is unsigned, so if a negative came from userspace, it'll 1596 convert to UINT_MAX, but we wan't to keep the userspace value. 1597 Almost the same as in php_fstat. This is ugly, but otherwise 1598 we would have to maintain a fully compatible struct stat. */ 1599 if ((int)stat_ssb.sb.st_rdev < 0) { 1600 ZVAL_LONG(&stat_rdev, (int)stat_ssb.sb.st_rdev); 1601 } else { 1602 ZVAL_LONG(&stat_rdev, stat_ssb.sb.st_rdev); 1603 } 1604 # else 1605 ZVAL_LONG(&stat_rdev, stat_ssb.sb.st_rdev); 1606 # endif 1607 #else 1608 ZVAL_LONG(&stat_rdev, -1); 1609 #endif 1610 ZVAL_LONG(&stat_size, stat_ssb.sb.st_size); 1611 ZVAL_LONG(&stat_atime, stat_ssb.sb.st_atime); 1612 ZVAL_LONG(&stat_mtime, stat_ssb.sb.st_mtime); 1613 ZVAL_LONG(&stat_ctime, stat_ssb.sb.st_ctime); 1614 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE 1615 ZVAL_LONG(&stat_blksize, stat_ssb.sb.st_blksize); 1616 #else 1617 ZVAL_LONG(&stat_blksize,-1); 1618 #endif 1619 #ifdef HAVE_ST_BLOCKS 1620 ZVAL_LONG(&stat_blocks, stat_ssb.sb.st_blocks); 1621 #else 1622 ZVAL_LONG(&stat_blocks,-1); 1623 #endif 1624 /* Store numeric indexes in proper order */ 1625 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_dev); 1626 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_ino); 1627 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_mode); 1628 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_nlink); 1629 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_uid); 1630 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_gid); 1631 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_rdev); 1632 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_size); 1633 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_atime); 1634 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_mtime); 1635 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_ctime); 1636 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_blksize); 1637 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &stat_blocks); 1638 1639 /* Store string indexes referencing the same zval*/ 1640 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[0], strlen(stat_sb_names[0]), &stat_dev); 1641 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[1], strlen(stat_sb_names[1]), &stat_ino); 1642 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[2], strlen(stat_sb_names[2]), &stat_mode); 1643 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[3], strlen(stat_sb_names[3]), &stat_nlink); 1644 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[4], strlen(stat_sb_names[4]), &stat_uid); 1645 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[5], strlen(stat_sb_names[5]), &stat_gid); 1646 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[6], strlen(stat_sb_names[6]), &stat_rdev); 1647 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[7], strlen(stat_sb_names[7]), &stat_size); 1648 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[8], strlen(stat_sb_names[8]), &stat_atime); 1649 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[9], strlen(stat_sb_names[9]), &stat_mtime); 1650 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[10], strlen(stat_sb_names[10]), &stat_ctime); 1651 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[11], strlen(stat_sb_names[11]), &stat_blksize); 1652 zend_hash_str_add_new(Z_ARRVAL_P(return_value), stat_sb_names[12], strlen(stat_sb_names[12]), &stat_blocks); 1653 } 1654 /* }}} */ 1655 1656 /* {{{ proto bool copy(string source_file, string destination_file [, resource context]) 1657 Copy a file */ 1658 PHP_FUNCTION(copy) 1659 { 1660 char *source, *target; 1661 size_t source_len, target_len; 1662 zval *zcontext = NULL; 1663 php_stream_context *context; 1664 1665 ZEND_PARSE_PARAMETERS_START(2, 3) 1666 Z_PARAM_PATH(source, source_len) 1667 Z_PARAM_PATH(target, target_len) 1668 Z_PARAM_OPTIONAL 1669 Z_PARAM_RESOURCE_EX(zcontext, 1, 0) 1670 ZEND_PARSE_PARAMETERS_END(); 1671 1672 if (php_stream_locate_url_wrapper(source, NULL, 0) == &php_plain_files_wrapper && php_check_open_basedir(source)) { 1673 RETURN_FALSE; 1674 } 1675 1676 context = php_stream_context_from_zval(zcontext, 0); 1677 1678 if (php_copy_file_ctx(source, target, 0, context) == SUCCESS) { 1679 RETURN_TRUE; 1680 } else { 1681 RETURN_FALSE; 1682 } 1683 } 1684 /* }}} */ 1685 1686 /* {{{ php_copy_file 1687 */ 1688 PHPAPI int php_copy_file(const char *src, const char *dest) 1689 { 1690 return php_copy_file_ctx(src, dest, 0, NULL); 1691 } 1692 /* }}} */ 1693 1694 /* {{{ php_copy_file_ex 1695 */ 1696 PHPAPI int php_copy_file_ex(const char *src, const char *dest, int src_flg) 1697 { 1698 return php_copy_file_ctx(src, dest, src_flg, NULL); 1699 } 1700 /* }}} */ 1701 1702 /* {{{ php_copy_file_ctx 1703 */ 1704 PHPAPI int php_copy_file_ctx(const char *src, const char *dest, int src_flg, php_stream_context *ctx) 1705 { 1706 php_stream *srcstream = NULL, *deststream = NULL; 1707 int ret = FAILURE; 1708 php_stream_statbuf src_s, dest_s; 1709 1710 switch (php_stream_stat_path_ex(src, 0, &src_s, ctx)) { 1711 case -1: 1712 /* non-statable stream */ 1713 goto safe_to_copy; 1714 break; 1715 case 0: 1716 break; 1717 default: /* failed to stat file, does not exist? */ 1718 return ret; 1719 } 1720 if (S_ISDIR(src_s.sb.st_mode)) { 1721 php_error_docref(NULL, E_WARNING, "The first argument to copy() function cannot be a directory"); 1722 return FAILURE; 1723 } 1724 1725 switch (php_stream_stat_path_ex(dest, PHP_STREAM_URL_STAT_QUIET | PHP_STREAM_URL_STAT_NOCACHE, &dest_s, ctx)) { 1726 case -1: 1727 /* non-statable stream */ 1728 goto safe_to_copy; 1729 break; 1730 case 0: 1731 break; 1732 default: /* failed to stat file, does not exist? */ 1733 return ret; 1734 } 1735 if (S_ISDIR(dest_s.sb.st_mode)) { 1736 php_error_docref(NULL, E_WARNING, "The second argument to copy() function cannot be a directory"); 1737 return FAILURE; 1738 } 1739 if (!src_s.sb.st_ino || !dest_s.sb.st_ino) { 1740 goto no_stat; 1741 } 1742 if (src_s.sb.st_ino == dest_s.sb.st_ino && src_s.sb.st_dev == dest_s.sb.st_dev) { 1743 return ret; 1744 } else { 1745 goto safe_to_copy; 1746 } 1747 no_stat: 1748 { 1749 char *sp, *dp; 1750 int res; 1751 1752 if ((sp = expand_filepath(src, NULL)) == NULL) { 1753 return ret; 1754 } 1755 if ((dp = expand_filepath(dest, NULL)) == NULL) { 1756 efree(sp); 1757 goto safe_to_copy; 1758 } 1759 1760 res = 1761 #ifndef PHP_WIN32 1762 !strcmp(sp, dp); 1763 #else 1764 !strcasecmp(sp, dp); 1765 #endif 1766 1767 efree(sp); 1768 efree(dp); 1769 if (res) { 1770 return ret; 1771 } 1772 } 1773 safe_to_copy: 1774 1775 srcstream = php_stream_open_wrapper_ex(src, "rb", src_flg | REPORT_ERRORS, NULL, ctx); 1776 1777 if (!srcstream) { 1778 return ret; 1779 } 1780 1781 deststream = php_stream_open_wrapper_ex(dest, "wb", REPORT_ERRORS, NULL, ctx); 1782 1783 if (srcstream && deststream) { 1784 ret = php_stream_copy_to_stream_ex(srcstream, deststream, PHP_STREAM_COPY_ALL, NULL); 1785 } 1786 if (srcstream) { 1787 php_stream_close(srcstream); 1788 } 1789 if (deststream) { 1790 php_stream_close(deststream); 1791 } 1792 return ret; 1793 } 1794 /* }}} */ 1795 1796 /* {{{ proto string fread(resource fp, int length) 1797 Binary-safe file read */ 1798 PHPAPI PHP_FUNCTION(fread) 1799 { 1800 zval *res; 1801 zend_long len; 1802 php_stream *stream; 1803 1804 ZEND_PARSE_PARAMETERS_START(2, 2) 1805 Z_PARAM_RESOURCE(res) 1806 Z_PARAM_LONG(len) 1807 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); 1808 1809 PHP_STREAM_TO_ZVAL(stream, res); 1810 1811 if (len <= 0) { 1812 php_error_docref(NULL, E_WARNING, "Length parameter must be greater than 0"); 1813 RETURN_FALSE; 1814 } 1815 1816 ZVAL_NEW_STR(return_value, zend_string_alloc(len, 0)); 1817 Z_STRLEN_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len); 1818 1819 /* needed because recv/read/gzread doesn't put a null at the end*/ 1820 Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0; 1821 1822 if (Z_STRLEN_P(return_value) < len / 2) { 1823 Z_STR_P(return_value) = zend_string_truncate(Z_STR_P(return_value), Z_STRLEN_P(return_value), 0); 1824 } 1825 } 1826 /* }}} */ 1827 1828 static const char *php_fgetcsv_lookup_trailing_spaces(const char *ptr, size_t len, const char delimiter) /* {{{ */ 1829 { 1830 int inc_len; 1831 unsigned char last_chars[2] = { 0, 0 }; 1832 1833 while (len > 0) { 1834 inc_len = (*ptr == '\0' ? 1 : php_mblen(ptr, len)); 1835 switch (inc_len) { 1836 case -2: 1837 case -1: 1838 inc_len = 1; 1839 php_mb_reset(); 1840 break; 1841 case 0: 1842 goto quit_loop; 1843 case 1: 1844 default: 1845 last_chars[0] = last_chars[1]; 1846 last_chars[1] = *ptr; 1847 break; 1848 } 1849 ptr += inc_len; 1850 len -= inc_len; 1851 } 1852 quit_loop: 1853 switch (last_chars[1]) { 1854 case '\n': 1855 if (last_chars[0] == '\r') { 1856 return ptr - 2; 1857 } 1858 /* break is omitted intentionally */ 1859 case '\r': 1860 return ptr - 1; 1861 } 1862 return ptr; 1863 } 1864 /* }}} */ 1865 1866 #define FPUTCSV_FLD_CHK(c) memchr(ZSTR_VAL(field_str), c, ZSTR_LEN(field_str)) 1867 1868 /* {{{ proto int fputcsv(resource fp, array fields [, string delimiter [, string enclosure [, string escape_char]]]) 1869 Format line as CSV and write to file pointer */ 1870 PHP_FUNCTION(fputcsv) 1871 { 1872 char delimiter = ','; /* allow this to be set as parameter */ 1873 char enclosure = '"'; /* allow this to be set as parameter */ 1874 char escape_char = '\\'; /* allow this to be set as parameter */ 1875 php_stream *stream; 1876 zval *fp = NULL, *fields = NULL; 1877 size_t ret; 1878 char *delimiter_str = NULL, *enclosure_str = NULL, *escape_str = NULL; 1879 size_t delimiter_str_len = 0, enclosure_str_len = 0, escape_str_len = 0; 1880 1881 ZEND_PARSE_PARAMETERS_START(2, 5) 1882 Z_PARAM_RESOURCE(fp) 1883 Z_PARAM_ARRAY(fields) 1884 Z_PARAM_OPTIONAL 1885 Z_PARAM_STRING(delimiter_str, delimiter_str_len) 1886 Z_PARAM_STRING(enclosure_str, enclosure_str_len) 1887 Z_PARAM_STRING(escape_str, escape_str_len) 1888 ZEND_PARSE_PARAMETERS_END(); 1889 1890 if (delimiter_str != NULL) { 1891 /* Make sure that there is at least one character in string */ 1892 if (delimiter_str_len < 1) { 1893 php_error_docref(NULL, E_WARNING, "delimiter must be a character"); 1894 RETURN_FALSE; 1895 } else if (delimiter_str_len > 1) { 1896 php_error_docref(NULL, E_NOTICE, "delimiter must be a single character"); 1897 } 1898 1899 /* use first character from string */ 1900 delimiter = *delimiter_str; 1901 } 1902 1903 if (enclosure_str != NULL) { 1904 if (enclosure_str_len < 1) { 1905 php_error_docref(NULL, E_WARNING, "enclosure must be a character"); 1906 RETURN_FALSE; 1907 } else if (enclosure_str_len > 1) { 1908 php_error_docref(NULL, E_NOTICE, "enclosure must be a single character"); 1909 } 1910 /* use first character from string */ 1911 enclosure = *enclosure_str; 1912 } 1913 1914 if (escape_str != NULL) { 1915 if (escape_str_len < 1) { 1916 php_error_docref(NULL, E_WARNING, "escape must be a character"); 1917 RETURN_FALSE; 1918 } else if (escape_str_len > 1) { 1919 php_error_docref(NULL, E_NOTICE, "escape must be a single character"); 1920 } 1921 /* use first character from string */ 1922 escape_char = *escape_str; 1923 } 1924 1925 PHP_STREAM_TO_ZVAL(stream, fp); 1926 1927 ret = php_fputcsv(stream, fields, delimiter, enclosure, escape_char); 1928 RETURN_LONG(ret); 1929 } 1930 /* }}} */ 1931 1932 /* {{{ PHPAPI size_t php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char) */ 1933 PHPAPI size_t php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char) 1934 { 1935 int count, i = 0; 1936 size_t ret; 1937 zval *field_tmp; 1938 smart_str csvline = {0}; 1939 1940 count = zend_hash_num_elements(Z_ARRVAL_P(fields)); 1941 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(fields), field_tmp) { 1942 zend_string *tmp_field_str; 1943 zend_string *field_str = zval_get_tmp_string(field_tmp, &tmp_field_str); 1944 1945 /* enclose a field that contains a delimiter, an enclosure character, or a newline */ 1946 if (FPUTCSV_FLD_CHK(delimiter) || 1947 FPUTCSV_FLD_CHK(enclosure) || 1948 FPUTCSV_FLD_CHK(escape_char) || 1949 FPUTCSV_FLD_CHK('\n') || 1950 FPUTCSV_FLD_CHK('\r') || 1951 FPUTCSV_FLD_CHK('\t') || 1952 FPUTCSV_FLD_CHK(' ') 1953 ) { 1954 char *ch = ZSTR_VAL(field_str); 1955 char *end = ch + ZSTR_LEN(field_str); 1956 int escaped = 0; 1957 1958 smart_str_appendc(&csvline, enclosure); 1959 while (ch < end) { 1960 if (*ch == escape_char) { 1961 escaped = 1; 1962 } else if (!escaped && *ch == enclosure) { 1963 smart_str_appendc(&csvline, enclosure); 1964 } else { 1965 escaped = 0; 1966 } 1967 smart_str_appendc(&csvline, *ch); 1968 ch++; 1969 } 1970 smart_str_appendc(&csvline, enclosure); 1971 } else { 1972 smart_str_append(&csvline, field_str); 1973 } 1974 1975 if (++i != count) { 1976 smart_str_appendl(&csvline, &delimiter, 1); 1977 } 1978 zend_tmp_string_release(tmp_field_str); 1979 } ZEND_HASH_FOREACH_END(); 1980 1981 smart_str_appendc(&csvline, '\n'); 1982 smart_str_0(&csvline); 1983 1984 ret = php_stream_write(stream, ZSTR_VAL(csvline.s), ZSTR_LEN(csvline.s)); 1985 1986 smart_str_free(&csvline); 1987 1988 return ret; 1989 } 1990 /* }}} */ 1991 1992 /* {{{ proto array fgetcsv(resource fp [,int length [, string delimiter [, string enclosure [, string escape]]]]) 1993 Get line from file pointer and parse for CSV fields */ 1994 PHP_FUNCTION(fgetcsv) 1995 { 1996 char delimiter = ','; /* allow this to be set as parameter */ 1997 char enclosure = '"'; /* allow this to be set as parameter */ 1998 char escape = '\\'; 1999 2000 /* first section exactly as php_fgetss */ 2001 2002 zend_long len = 0; 2003 size_t buf_len; 2004 char *buf; 2005 php_stream *stream; 2006 2007 { 2008 zval *fd, *len_zv = NULL; 2009 char *delimiter_str = NULL; 2010 size_t delimiter_str_len = 0; 2011 char *enclosure_str = NULL; 2012 size_t enclosure_str_len = 0; 2013 char *escape_str = NULL; 2014 size_t escape_str_len = 0; 2015 2016 ZEND_PARSE_PARAMETERS_START(1, 5) 2017 Z_PARAM_RESOURCE(fd) 2018 Z_PARAM_OPTIONAL 2019 Z_PARAM_ZVAL(len_zv) 2020 Z_PARAM_STRING(delimiter_str, delimiter_str_len) 2021 Z_PARAM_STRING(enclosure_str, enclosure_str_len) 2022 Z_PARAM_STRING(escape_str, escape_str_len) 2023 ZEND_PARSE_PARAMETERS_END(); 2024 2025 if (delimiter_str != NULL) { 2026 /* Make sure that there is at least one character in string */ 2027 if (delimiter_str_len < 1) { 2028 php_error_docref(NULL, E_WARNING, "delimiter must be a character"); 2029 RETURN_FALSE; 2030 } else if (delimiter_str_len > 1) { 2031 php_error_docref(NULL, E_NOTICE, "delimiter must be a single character"); 2032 } 2033 2034 /* use first character from string */ 2035 delimiter = delimiter_str[0]; 2036 } 2037 2038 if (enclosure_str != NULL) { 2039 if (enclosure_str_len < 1) { 2040 php_error_docref(NULL, E_WARNING, "enclosure must be a character"); 2041 RETURN_FALSE; 2042 } else if (enclosure_str_len > 1) { 2043 php_error_docref(NULL, E_NOTICE, "enclosure must be a single character"); 2044 } 2045 2046 /* use first character from string */ 2047 enclosure = enclosure_str[0]; 2048 } 2049 2050 if (escape_str != NULL) { 2051 if (escape_str_len < 1) { 2052 php_error_docref(NULL, E_WARNING, "escape must be character"); 2053 RETURN_FALSE; 2054 } else if (escape_str_len > 1) { 2055 php_error_docref(NULL, E_NOTICE, "escape must be a single character"); 2056 } 2057 2058 escape = escape_str[0]; 2059 } 2060 2061 if (len_zv != NULL && Z_TYPE_P(len_zv) != IS_NULL) { 2062 len = zval_get_long(len_zv); 2063 if (len < 0) { 2064 php_error_docref(NULL, E_WARNING, "Length parameter may not be negative"); 2065 RETURN_FALSE; 2066 } else if (len == 0) { 2067 len = -1; 2068 } 2069 } else { 2070 len = -1; 2071 } 2072 2073 PHP_STREAM_TO_ZVAL(stream, fd); 2074 } 2075 2076 if (len < 0) { 2077 if ((buf = php_stream_get_line(stream, NULL, 0, &buf_len)) == NULL) { 2078 RETURN_FALSE; 2079 } 2080 } else { 2081 buf = emalloc(len + 1); 2082 if (php_stream_get_line(stream, buf, len + 1, &buf_len) == NULL) { 2083 efree(buf); 2084 RETURN_FALSE; 2085 } 2086 } 2087 2088 php_fgetcsv(stream, delimiter, enclosure, escape, buf_len, buf, return_value); 2089 } 2090 /* }}} */ 2091 2092 PHPAPI void php_fgetcsv(php_stream *stream, char delimiter, char enclosure, char escape_char, size_t buf_len, char *buf, zval *return_value) /* {{{ */ 2093 { 2094 char *temp, *tptr, *bptr, *line_end, *limit; 2095 size_t temp_len, line_end_len; 2096 int inc_len; 2097 zend_bool first_field = 1; 2098 2099 /* initialize internal state */ 2100 php_mb_reset(); 2101 2102 /* Now into new section that parses buf for delimiter/enclosure fields */ 2103 2104 /* Strip trailing space from buf, saving end of line in case required for enclosure field */ 2105 2106 bptr = buf; 2107 tptr = (char *)php_fgetcsv_lookup_trailing_spaces(buf, buf_len, delimiter); 2108 line_end_len = buf_len - (size_t)(tptr - buf); 2109 line_end = limit = tptr; 2110 2111 /* reserve workspace for building each individual field */ 2112 temp_len = buf_len; 2113 temp = emalloc(temp_len + line_end_len + 1); 2114 2115 /* Initialize return array */ 2116 array_init(return_value); 2117 2118 /* Main loop to read CSV fields */ 2119 /* NB this routine will return a single null entry for a blank line */ 2120 2121 do { 2122 char *comp_end, *hunk_begin; 2123 2124 tptr = temp; 2125 2126 inc_len = (bptr < limit ? (*bptr == '\0' ? 1 : php_mblen(bptr, limit - bptr)): 0); 2127 if (inc_len == 1) { 2128 char *tmp = bptr; 2129 while ((*tmp != delimiter) && isspace((int)*(unsigned char *)tmp)) { 2130 tmp++; 2131 } 2132 if (*tmp == enclosure) { 2133 bptr = tmp; 2134 } 2135 } 2136 2137 if (first_field && bptr == line_end) { 2138 add_next_index_null(return_value); 2139 break; 2140 } 2141 first_field = 0; 2142 /* 2. Read field, leaving bptr pointing at start of next field */ 2143 if (inc_len != 0 && *bptr == enclosure) { 2144 int state = 0; 2145 2146 bptr++; /* move on to first character in field */ 2147 hunk_begin = bptr; 2148 2149 /* 2A. handle enclosure delimited field */ 2150 for (;;) { 2151 switch (inc_len) { 2152 case 0: 2153 switch (state) { 2154 case 2: 2155 memcpy(tptr, hunk_begin, bptr - hunk_begin - 1); 2156 tptr += (bptr - hunk_begin - 1); 2157 hunk_begin = bptr; 2158 goto quit_loop_2; 2159 2160 case 1: 2161 memcpy(tptr, hunk_begin, bptr - hunk_begin); 2162 tptr += (bptr - hunk_begin); 2163 hunk_begin = bptr; 2164 /* break is omitted intentionally */ 2165 2166 case 0: { 2167 char *new_buf; 2168 size_t new_len; 2169 char *new_temp; 2170 2171 if (hunk_begin != line_end) { 2172 memcpy(tptr, hunk_begin, bptr - hunk_begin); 2173 tptr += (bptr - hunk_begin); 2174 hunk_begin = bptr; 2175 } 2176 2177 /* add the embedded line end to the field */ 2178 memcpy(tptr, line_end, line_end_len); 2179 tptr += line_end_len; 2180 2181 if (stream == NULL) { 2182 goto quit_loop_2; 2183 } else if ((new_buf = php_stream_get_line(stream, NULL, 0, &new_len)) == NULL) { 2184 /* we've got an unterminated enclosure, 2185 * assign all the data from the start of 2186 * the enclosure to end of data to the 2187 * last element */ 2188 if ((size_t)temp_len > (size_t)(limit - buf)) { 2189 goto quit_loop_2; 2190 } 2191 zend_array_destroy(Z_ARR_P(return_value)); 2192 RETVAL_FALSE; 2193 goto out; 2194 } 2195 temp_len += new_len; 2196 new_temp = erealloc(temp, temp_len); 2197 tptr = new_temp + (size_t)(tptr - temp); 2198 temp = new_temp; 2199 2200 efree(buf); 2201 buf_len = new_len; 2202 bptr = buf = new_buf; 2203 hunk_begin = buf; 2204 2205 line_end = limit = (char *)php_fgetcsv_lookup_trailing_spaces(buf, buf_len, delimiter); 2206 line_end_len = buf_len - (size_t)(limit - buf); 2207 2208 state = 0; 2209 } break; 2210 } 2211 break; 2212 2213 case -2: 2214 case -1: 2215 php_mb_reset(); 2216 /* break is omitted intentionally */ 2217 case 1: 2218 /* we need to determine if the enclosure is 2219 * 'real' or is it escaped */ 2220 switch (state) { 2221 case 1: /* escaped */ 2222 bptr++; 2223 state = 0; 2224 break; 2225 case 2: /* embedded enclosure ? let's check it */ 2226 if (*bptr != enclosure) { 2227 /* real enclosure */ 2228 memcpy(tptr, hunk_begin, bptr - hunk_begin - 1); 2229 tptr += (bptr - hunk_begin - 1); 2230 hunk_begin = bptr; 2231 goto quit_loop_2; 2232 } 2233 memcpy(tptr, hunk_begin, bptr - hunk_begin); 2234 tptr += (bptr - hunk_begin); 2235 bptr++; 2236 hunk_begin = bptr; 2237 state = 0; 2238 break; 2239 default: 2240 if (*bptr == enclosure) { 2241 state = 2; 2242 } else if (*bptr == escape_char) { 2243 state = 1; 2244 } 2245 bptr++; 2246 break; 2247 } 2248 break; 2249 2250 default: 2251 switch (state) { 2252 case 2: 2253 /* real enclosure */ 2254 memcpy(tptr, hunk_begin, bptr - hunk_begin - 1); 2255 tptr += (bptr - hunk_begin - 1); 2256 hunk_begin = bptr; 2257 goto quit_loop_2; 2258 case 1: 2259 bptr += inc_len; 2260 memcpy(tptr, hunk_begin, bptr - hunk_begin); 2261 tptr += (bptr - hunk_begin); 2262 hunk_begin = bptr; 2263 state = 0; 2264 break; 2265 default: 2266 bptr += inc_len; 2267 break; 2268 } 2269 break; 2270 } 2271 inc_len = (bptr < limit ? (*bptr == '\0' ? 1 : php_mblen(bptr, limit - bptr)): 0); 2272 } 2273 2274 quit_loop_2: 2275 /* look up for a delimiter */ 2276 for (;;) { 2277 switch (inc_len) { 2278 case 0: 2279 goto quit_loop_3; 2280 2281 case -2: 2282 case -1: 2283 inc_len = 1; 2284 php_mb_reset(); 2285 /* break is omitted intentionally */ 2286 case 1: 2287 if (*bptr == delimiter) { 2288 goto quit_loop_3; 2289 } 2290 break; 2291 default: 2292 break; 2293 } 2294 bptr += inc_len; 2295 inc_len = (bptr < limit ? (*bptr == '\0' ? 1 : php_mblen(bptr, limit - bptr)): 0); 2296 } 2297 2298 quit_loop_3: 2299 memcpy(tptr, hunk_begin, bptr - hunk_begin); 2300 tptr += (bptr - hunk_begin); 2301 bptr += inc_len; 2302 comp_end = tptr; 2303 } else { 2304 /* 2B. Handle non-enclosure field */ 2305 2306 hunk_begin = bptr; 2307 2308 for (;;) { 2309 switch (inc_len) { 2310 case 0: 2311 goto quit_loop_4; 2312 case -2: 2313 case -1: 2314 inc_len = 1; 2315 php_mb_reset(); 2316 /* break is omitted intentionally */ 2317 case 1: 2318 if (*bptr == delimiter) { 2319 goto quit_loop_4; 2320 } 2321 break; 2322 default: 2323 break; 2324 } 2325 bptr += inc_len; 2326 inc_len = (bptr < limit ? (*bptr == '\0' ? 1 : php_mblen(bptr, limit - bptr)): 0); 2327 } 2328 quit_loop_4: 2329 memcpy(tptr, hunk_begin, bptr - hunk_begin); 2330 tptr += (bptr - hunk_begin); 2331 2332 comp_end = (char *)php_fgetcsv_lookup_trailing_spaces(temp, tptr - temp, delimiter); 2333 if (*bptr == delimiter) { 2334 bptr++; 2335 } 2336 } 2337 2338 /* 3. Now pass our field back to php */ 2339 *comp_end = '\0'; 2340 add_next_index_stringl(return_value, temp, comp_end - temp); 2341 } while (inc_len > 0); 2342 2343 out: 2344 efree(temp); 2345 if (stream) { 2346 efree(buf); 2347 } 2348 } 2349 /* }}} */ 2350 2351 #if HAVE_REALPATH || defined(ZTS) 2352 /* {{{ proto string realpath(string path) 2353 Return the resolved path */ 2354 PHP_FUNCTION(realpath) 2355 { 2356 char *filename; 2357 size_t filename_len; 2358 char resolved_path_buff[MAXPATHLEN]; 2359 2360 ZEND_PARSE_PARAMETERS_START(1, 1) 2361 Z_PARAM_PATH(filename, filename_len) 2362 ZEND_PARSE_PARAMETERS_END(); 2363 2364 if (VCWD_REALPATH(filename, resolved_path_buff)) { 2365 if (php_check_open_basedir(resolved_path_buff)) { 2366 RETURN_FALSE; 2367 } 2368 2369 #ifdef ZTS 2370 if (VCWD_ACCESS(resolved_path_buff, F_OK)) { 2371 RETURN_FALSE; 2372 } 2373 #endif 2374 RETURN_STRING(resolved_path_buff); 2375 } else { 2376 RETURN_FALSE; 2377 } 2378 } 2379 /* }}} */ 2380 #endif 2381 2382 /* See http://www.w3.org/TR/html4/intro/sgmltut.html#h-3.2.2 */ 2383 #define PHP_META_HTML401_CHARS "-_.:" 2384 2385 /* {{{ php_next_meta_token 2386 Tokenizes an HTML file for get_meta_tags */ 2387 php_meta_tags_token php_next_meta_token(php_meta_tags_data *md) 2388 { 2389 int ch = 0, compliment; 2390 char buff[META_DEF_BUFSIZE + 1]; 2391 2392 memset((void *)buff, 0, META_DEF_BUFSIZE + 1); 2393 2394 while (md->ulc || (!php_stream_eof(md->stream) && (ch = php_stream_getc(md->stream)))) { 2395 if (php_stream_eof(md->stream)) { 2396 break; 2397 } 2398 2399 if (md->ulc) { 2400 ch = md->lc; 2401 md->ulc = 0; 2402 } 2403 2404 switch (ch) { 2405 case '<': 2406 return TOK_OPENTAG; 2407 break; 2408 2409 case '>': 2410 return TOK_CLOSETAG; 2411 break; 2412 2413 case '=': 2414 return TOK_EQUAL; 2415 break; 2416 case '/': 2417 return TOK_SLASH; 2418 break; 2419 2420 case '\'': 2421 case '"': 2422 compliment = ch; 2423 md->token_len = 0; 2424 while (!php_stream_eof(md->stream) && (ch = php_stream_getc(md->stream)) && ch != compliment && ch != '<' && ch != '>') { 2425 buff[(md->token_len)++] = ch; 2426 2427 if (md->token_len == META_DEF_BUFSIZE) { 2428 break; 2429 } 2430 } 2431 2432 if (ch == '<' || ch == '>') { 2433 /* Was just an apostrohpe */ 2434 md->ulc = 1; 2435 md->lc = ch; 2436 } 2437 2438 /* We don't need to alloc unless we are in a meta tag */ 2439 if (md->in_meta) { 2440 md->token_data = (char *) emalloc(md->token_len + 1); 2441 memcpy(md->token_data, buff, md->token_len+1); 2442 } 2443 2444 return TOK_STRING; 2445 break; 2446 2447 case '\n': 2448 case '\r': 2449 case '\t': 2450 break; 2451 2452 case ' ': 2453 return TOK_SPACE; 2454 break; 2455 2456 default: 2457 if (isalnum(ch)) { 2458 md->token_len = 0; 2459 buff[(md->token_len)++] = ch; 2460 while (!php_stream_eof(md->stream) && (ch = php_stream_getc(md->stream)) && (isalnum(ch) || strchr(PHP_META_HTML401_CHARS, ch))) { 2461 buff[(md->token_len)++] = ch; 2462 2463 if (md->token_len == META_DEF_BUFSIZE) { 2464 break; 2465 } 2466 } 2467 2468 /* This is ugly, but we have to replace ungetc */ 2469 if (!isalpha(ch) && ch != '-') { 2470 md->ulc = 1; 2471 md->lc = ch; 2472 } 2473 2474 md->token_data = (char *) emalloc(md->token_len + 1); 2475 memcpy(md->token_data, buff, md->token_len+1); 2476 2477 return TOK_ID; 2478 } else { 2479 return TOK_OTHER; 2480 } 2481 break; 2482 } 2483 } 2484 2485 return TOK_EOF; 2486 } 2487 /* }}} */ 2488 2489 #ifdef HAVE_FNMATCH 2490 /* {{{ proto bool fnmatch(string pattern, string filename [, int flags]) 2491 Match filename against pattern */ 2492 PHP_FUNCTION(fnmatch) 2493 { 2494 char *pattern, *filename; 2495 size_t pattern_len, filename_len; 2496 zend_long flags = 0; 2497 2498 ZEND_PARSE_PARAMETERS_START(2, 3) 2499 Z_PARAM_PATH(pattern, pattern_len) 2500 Z_PARAM_PATH(filename, filename_len) 2501 Z_PARAM_OPTIONAL 2502 Z_PARAM_LONG(flags) 2503 ZEND_PARSE_PARAMETERS_END(); 2504 2505 if (filename_len >= MAXPATHLEN) { 2506 php_error_docref(NULL, E_WARNING, "Filename exceeds the maximum allowed length of %d characters", MAXPATHLEN); 2507 RETURN_FALSE; 2508 } 2509 if (pattern_len >= MAXPATHLEN) { 2510 php_error_docref(NULL, E_WARNING, "Pattern exceeds the maximum allowed length of %d characters", MAXPATHLEN); 2511 RETURN_FALSE; 2512 } 2513 2514 RETURN_BOOL( ! fnmatch( pattern, filename, (int)flags )); 2515 } 2516 /* }}} */ 2517 #endif 2518 2519 /* {{{ proto string sys_get_temp_dir() 2520 Returns directory path used for temporary files */ 2521 PHP_FUNCTION(sys_get_temp_dir) 2522 { 2523 if (zend_parse_parameters_none() == FAILURE) { 2524 return; 2525 } 2526 RETURN_STRING((char *)php_get_temporary_directory()); 2527 } 2528 /* }}} */ 2529 2530 /* 2531 * Local variables: 2532 * tab-width: 4 2533 * c-basic-offset: 4 2534 * End: 2535 * vim600: noet sw=4 ts=4 fdm=marker 2536 * vim<600: noet sw=4 ts=4 2537 */ 2538
