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