/src/php-src/Zend/zend_stream.c

Source
/*
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.00 of the Zend license,     |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.zend.com/license/2_00.txt.                                |
   | If you did not receive a copy of the Zend license and are unable to  |
   | obtain it through the world-wide-web, please send a note to          |
   | license@zend.com so we can mail you a copy immediately.              |
   +----------------------------------------------------------------------+
   | Authors: Wez Furlong <wez@thebrainroom.com>                          |
   |          Scott MacVicar <scottmac@php.net>                           |
   |          Nuno Lopes <nlopess@php.net>                                |
   |          Marcus Boerger <helly@php.net>                              |
   +----------------------------------------------------------------------+
*/

#include "zend.h"
#include "zend_compile.h"
#include "zend_stream.h"

ZEND_DLIMPORT int isatty(int fd);

static ssize_t zend_stream_stdio_reader(void *handle, char *buf, size_t len) /* {{{ */
{
  return fread(buf, 1, len, (FILE*)handle);
} /* }}} */

static void zend_stream_stdio_closer(void *handle) /* {{{ */
{
  if (handle && (FILE*)handle != stdin) {
    fclose((FILE*)handle);
  }
} /* }}} */

static size_t zend_stream_stdio_fsizer(void *handle) /* {{{ */
{
  zend_stat_t buf = {0};
  if (handle && zend_fstat(fileno((FILE*)handle), &buf) == 0) {
#ifdef S_ISREG
    if (!S_ISREG(buf.st_mode)) {
      return 0;
    }
#endif
    return buf.st_size;
  }
  return -1;
} /* }}} */

static size_t zend_stream_fsize(zend_file_handle *file_handle) /* {{{ */
{
  ZEND_ASSERT(file_handle->type == ZEND_HANDLE_STREAM);
  if (file_handle->handle.stream.isatty) {
    return 0;
  }
  return file_handle->handle.stream.fsizer(file_handle->handle.stream.handle);
} /* }}} */

ZEND_API void zend_stream_init_fp(zend_file_handle *handle, FILE *fp, const char *filename) {
  memset(handle, 0, sizeof(zend_file_handle));
  handle->type = ZEND_HANDLE_FP;
  handle->handle.fp = fp;
  handle->filename = filename ? zend_string_init(filename, strlen(filename), 0) : NULL;
}

ZEND_API void zend_stream_init_filename(zend_file_handle *handle, const char *filename) {
  memset(handle, 0, sizeof(zend_file_handle));
  handle->type = ZEND_HANDLE_FILENAME;
  handle->filename = filename ? zend_string_init(filename, strlen(filename), 0) : NULL;
}

ZEND_API void zend_stream_init_filename_ex(zend_file_handle *handle, zend_string *filename) {
  memset(handle, 0, sizeof(zend_file_handle));
  handle->type = ZEND_HANDLE_FILENAME;
  handle->filename = zend_string_copy(filename);
}

ZEND_API zend_result zend_stream_open(zend_file_handle *handle) /* {{{ */
{
  zend_string *opened_path;

  ZEND_ASSERT(handle->type == ZEND_HANDLE_FILENAME);
  if (zend_stream_open_function) {
    return zend_stream_open_function(handle);
  }

  handle->handle.fp = zend_fopen(handle->filename, &opened_path);
  if (!handle->handle.fp) {
    return FAILURE;
  }
  handle->type = ZEND_HANDLE_FP;
  return SUCCESS;
} /* }}} */

static int zend_stream_getc(zend_file_handle *file_handle) /* {{{ */
{
  char buf;

  if (file_handle->handle.stream.reader(file_handle->handle.stream.handle, &buf, sizeof(buf))) {
    return (int)buf;
  }
  return EOF;
} /* }}} */

static ssize_t zend_stream_read(zend_file_handle *file_handle, char *buf, size_t len) /* {{{ */
{
  if (file_handle->handle.stream.isatty) {
    int c = '*';
    size_t n;

    for (n = 0; n < len && (c = zend_stream_getc(file_handle)) != EOF && c != '\n'; ++n)  {
      buf[n] = (char)c;
    }
    if (c == '\n') {
      buf[n++] = (char)c;
    }

    return n;
  }
  return file_handle->handle.stream.reader(file_handle->handle.stream.handle, buf, len);
} /* }}} */

ZEND_API zend_result zend_stream_fixup(zend_file_handle *file_handle, char **buf, size_t *len) /* {{{ */
{
  size_t file_size;

  if (file_handle->buf) {
    *buf = file_handle->buf;
    *len = file_handle->len;
    return SUCCESS;
  }

  if (file_handle->type == ZEND_HANDLE_FILENAME) {
    if (zend_stream_open(file_handle) == FAILURE) {
      return FAILURE;
    }
  }

  if (file_handle->type == ZEND_HANDLE_FP) {
    if (!file_handle->handle.fp) {
      return FAILURE;
    }

    file_handle->type = ZEND_HANDLE_STREAM;
    file_handle->handle.stream.handle = file_handle->handle.fp;
    file_handle->handle.stream.isatty = isatty(fileno((FILE *)file_handle->handle.stream.handle));
    file_handle->handle.stream.reader = (zend_stream_reader_t)zend_stream_stdio_reader;
    file_handle->handle.stream.closer = (zend_stream_closer_t)zend_stream_stdio_closer;
    file_handle->handle.stream.fsizer = (zend_stream_fsizer_t)zend_stream_stdio_fsizer;
  }

  file_size = zend_stream_fsize(file_handle);
  if (file_size == (size_t)-1) {
    return FAILURE;
  }

  if (file_size) {
    ssize_t read;
    size_t size = 0;
    *buf = safe_emalloc(1, file_size, ZEND_MMAP_AHEAD);
    while ((read = zend_stream_read(file_handle, *buf + size, file_size - size)) > 0) {
      size += read;
    }
    if (read < 0) {
      efree(*buf);
      return FAILURE;
    }
    file_handle->buf = *buf;
    file_handle->len = size;
  } else {
    size_t size = 0, remain = 4*1024;
    ssize_t read;
    *buf = emalloc(remain);

    while ((read = zend_stream_read(file_handle, *buf + size, remain)) > 0) {
      size   += read;
      remain -= read;

      if (remain == 0) {
        *buf   = safe_erealloc(*buf, size, 2, 0);
        remain = size;
      }
    }
    if (read < 0) {
      efree(*buf);
      return FAILURE;
    }

    file_handle->len = size;
    if (size && remain < ZEND_MMAP_AHEAD) {
      *buf = safe_erealloc(*buf, size, 1, ZEND_MMAP_AHEAD);
    }
    file_handle->buf = *buf;
  }

  if (file_handle->len == 0) {
    *buf = erealloc(*buf, ZEND_MMAP_AHEAD);
    file_handle->buf = *buf;
  }

  memset(file_handle->buf + file_handle->len, 0, ZEND_MMAP_AHEAD);

  *buf = file_handle->buf;
  *len = file_handle->len;

  return SUCCESS;
} /* }}} */

static void zend_file_handle_dtor(zend_file_handle *fh) /* {{{ */
{
  switch (fh->type) {
    case ZEND_HANDLE_FP:
      if (fh->handle.fp) {
        fclose(fh->handle.fp);
        fh->handle.fp = NULL;
      }
      break;
    case ZEND_HANDLE_STREAM:
      if (fh->handle.stream.closer && fh->handle.stream.handle) {
        fh->handle.stream.closer(fh->handle.stream.handle);
      }
      fh->handle.stream.handle = NULL;
      break;
    case ZEND_HANDLE_FILENAME:
      /* We're only supposed to get here when destructing the used_files hash,
       * which doesn't really contain open files, but references to their names/paths
       */
      break;
  }
  if (fh->opened_path) {
    zend_string_release_ex(fh->opened_path, 0);
    fh->opened_path = NULL;
  }
  if (fh->buf) {
    efree(fh->buf);
    fh->buf = NULL;
  }
  if (fh->filename) {
    zend_string_release(fh->filename);
    fh->filename = NULL;
  }
}
/* }}} */

/* return int to be compatible with Zend linked list API */
static int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2) /* {{{ */
{
  if (fh1->type != fh2->type) {
    return 0;
  }
  switch (fh1->type) {
    case ZEND_HANDLE_FILENAME:
      return zend_string_equals(fh1->filename, fh2->filename);
    case ZEND_HANDLE_FP:
      return fh1->handle.fp == fh2->handle.fp;
    case ZEND_HANDLE_STREAM:
      return fh1->handle.stream.handle == fh2->handle.stream.handle;
    default:
      return 0;
  }
  return 0;
} /* }}} */

ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle) /* {{{ */
{
  if (file_handle->in_list) {
    zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
    /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
    file_handle->opened_path = NULL;
    file_handle->filename = NULL;
  } else {
    zend_file_handle_dtor(file_handle);
  }
} /* }}} */

void zend_stream_init(void) /* {{{ */
{
  zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) zend_file_handle_dtor, 0);
} /* }}} */

void zend_stream_shutdown(void) /* {{{ */
{
  zend_llist_destroy(&CG(open_files));
} /* }}} */

Coverage Report

Created: 2025-09-27 06:26

Line	Count	Source
1		/*
2		+----------------------------------------------------------------------+
3		\| Zend Engine \|
4		+----------------------------------------------------------------------+
5		\| Copyright (c) Zend Technologies Ltd. (http://www.zend.com) \|
6		+----------------------------------------------------------------------+
7		\| This source file is subject to version 2.00 of the Zend 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.zend.com/license/2_00.txt. \|
11		\| If you did not receive a copy of the Zend license and are unable to \|
12		\| obtain it through the world-wide-web, please send a note to \|
13		\| license@zend.com so we can mail you a copy immediately. \|
14		+----------------------------------------------------------------------+
15		\| Authors: Wez Furlong <wez@thebrainroom.com> \|
16		\| Scott MacVicar <scottmac@php.net> \|
17		\| Nuno Lopes <nlopess@php.net> \|
18		\| Marcus Boerger <helly@php.net> \|
19		+----------------------------------------------------------------------+
20		*/
21
22		#include "zend.h"
23		#include "zend_compile.h"
24		#include "zend_stream.h"
25
26		ZEND_DLIMPORT int isatty(int fd);
27
28		static ssize_t zend_stream_stdio_reader(void handle, char buf, size_t len) /* {{{ */
29	0	{
30	0	return fread(buf, 1, len, (FILE*)handle);
31	0	} /* }}} */
32
33		static void zend_stream_stdio_closer(void handle) / {{{ */
34	0	{
35	0	if (handle && (FILE*)handle != stdin) {
36	0	fclose((FILE*)handle);
37	0	}
38	0	} /* }}} */
39
40		static size_t zend_stream_stdio_fsizer(void handle) / {{{ */
41	0	{
42	0	zend_stat_t buf = {0};
43	0	if (handle && zend_fstat(fileno((FILE*)handle), &buf) == 0) {
44	0	#ifdef S_ISREG
45	0	if (!S_ISREG(buf.st_mode)) {
46	0	return 0;
47	0	}
48	0	#endif
49	0	return buf.st_size;
50	0	}
51	0	return -1;
52	0	} /* }}} */
53
54		static size_t zend_stream_fsize(zend_file_handle file_handle) / {{{ */
55	115	{
56	115	ZEND_ASSERT(file_handle->type == ZEND_HANDLE_STREAM);
57	115	if (file_handle->handle.stream.isatty) {
58	0	return 0;
59	0	}
60	115	return file_handle->handle.stream.fsizer(file_handle->handle.stream.handle);
61	115	} /* }}} */
62
63	0	ZEND_API void zend_stream_init_fp(zend_file_handle handle, FILE fp, const char *filename) {
64	0	memset(handle, 0, sizeof(zend_file_handle));
65	0	handle->type = ZEND_HANDLE_FP;
66	0	handle->handle.fp = fp;
67	0	handle->filename = filename ? zend_string_init(filename, strlen(filename), 0) : NULL;
68	0	}
69
70	174k	ZEND_API void zend_stream_init_filename(zend_file_handle handle, const char filename) {
71	174k	memset(handle, 0, sizeof(zend_file_handle));
72	174k	handle->type = ZEND_HANDLE_FILENAME;
73	174k	handle->filename = filename ? zend_string_init(filename, strlen(filename), 0) : NULL;
74	174k	}
75
76	128k	ZEND_API void zend_stream_init_filename_ex(zend_file_handle handle, zend_string filename) {
77	128k	memset(handle, 0, sizeof(zend_file_handle));
78	128k	handle->type = ZEND_HANDLE_FILENAME;
79	128k	handle->filename = zend_string_copy(filename);
80	128k	}
81
82		ZEND_API zend_result zend_stream_open(zend_file_handle handle) / {{{ */
83	286	{
84	286	zend_string *opened_path;
85
86	286	ZEND_ASSERT(handle->type == ZEND_HANDLE_FILENAME);
87	286	if (zend_stream_open_function) {
88	286	return zend_stream_open_function(handle);
89	286	}
90
91	0	handle->handle.fp = zend_fopen(handle->filename, &opened_path);
92	0	if (!handle->handle.fp) {
93	0	return FAILURE;
94	0	}
95	0	handle->type = ZEND_HANDLE_FP;
96	0	return SUCCESS;
97	0	} /* }}} */
98
99		static int zend_stream_getc(zend_file_handle file_handle) / {{{ */
100	0	{
101	0	char buf;
102
103	0	if (file_handle->handle.stream.reader(file_handle->handle.stream.handle, &buf, sizeof(buf))) {
104	0	return (int)buf;
105	0	}
106	0	return EOF;
107	0	} /* }}} */
108
109		static ssize_t zend_stream_read(zend_file_handle file_handle, char buf, size_t len) /* {{{ */
110	130	{
111	130	if (file_handle->handle.stream.isatty) {
112	0	int c = '*';
113	0	size_t n;
114
115	0	for (n = 0; n < len && (c = zend_stream_getc(file_handle)) != EOF && c != '\n'; ++n) {
116	0	buf[n] = (char)c;
117	0	}
118	0	if (c == '\n') {
119	0	buf[n++] = (char)c;
120	0	}
121
122	0	return n;
123	0	}
124	130	return file_handle->handle.stream.reader(file_handle->handle.stream.handle, buf, len);
125	130	} /* }}} */
126
127		ZEND_API zend_result zend_stream_fixup(zend_file_handle file_handle, char buf, size_t len) /* {{{ */
128	134k	{
129	134k	size_t file_size;
130
131	134k	if (file_handle->buf) {
132	134k	*buf = file_handle->buf;
133	134k	*len = file_handle->len;
134	134k	return SUCCESS;
135	134k	}
136
137	158	if (file_handle->type == ZEND_HANDLE_FILENAME) {
138	150	if (zend_stream_open(file_handle) == FAILURE) {
139	43	return FAILURE;
140	43	}
141	150	}
142
143	115	if (file_handle->type == ZEND_HANDLE_FP) {
144	0	if (!file_handle->handle.fp) {
145	0	return FAILURE;
146	0	}
147
148	0	file_handle->type = ZEND_HANDLE_STREAM;
149	0	file_handle->handle.stream.handle = file_handle->handle.fp;
150	0	file_handle->handle.stream.isatty = isatty(fileno((FILE *)file_handle->handle.stream.handle));
151	0	file_handle->handle.stream.reader = (zend_stream_reader_t)zend_stream_stdio_reader;
152	0	file_handle->handle.stream.closer = (zend_stream_closer_t)zend_stream_stdio_closer;
153	0	file_handle->handle.stream.fsizer = (zend_stream_fsizer_t)zend_stream_stdio_fsizer;
154	0	}
155
156	115	file_size = zend_stream_fsize(file_handle);
157	115	if (file_size == (size_t)-1) {
158	0	return FAILURE;
159	0	}
160
161	115	if (file_size) {
162	21	ssize_t read;
163	21	size_t size = 0;
164	21	*buf = safe_emalloc(1, file_size, ZEND_MMAP_AHEAD);
165	30	while ((read = zend_stream_read(file_handle, *buf + size, file_size - size)) > 0) {
166	9	size += read;
167	9	}
168	21	if (read < 0) {
169	5	efree(*buf);
170	5	return FAILURE;
171	5	}
172	16	file_handle->buf = *buf;
173	16	file_handle->len = size;
174	94	} else {
175	94	size_t size = 0, remain = 4*1024;
176	94	ssize_t read;
177	94	*buf = emalloc(remain);
178
179	100	while ((read = zend_stream_read(file_handle, *buf + size, remain)) > 0) {
180	6	size += read;
181	6	remain -= read;
182
183	6	if (remain == 0) {
184	0	buf = safe_erealloc(buf, size, 2, 0);
185	0	remain = size;
186	0	}
187	6	}
188	94	if (read < 0) {
189	35	efree(*buf);
190	35	return FAILURE;
191	35	}
192
193	59	file_handle->len = size;
194	59	if (size && remain < ZEND_MMAP_AHEAD) {
195	0	buf = safe_erealloc(buf, size, 1, ZEND_MMAP_AHEAD);
196	0	}
197	59	file_handle->buf = *buf;
198	59	}
199
200	75	if (file_handle->len == 0) {
201	51	buf = erealloc(buf, ZEND_MMAP_AHEAD);
202	51	file_handle->buf = *buf;
203	51	}
204
205	75	memset(file_handle->buf + file_handle->len, 0, ZEND_MMAP_AHEAD);
206
207	75	*buf = file_handle->buf;
208	75	*len = file_handle->len;
209
210	75	return SUCCESS;
211	115	} /* }}} */
212
213		static void zend_file_handle_dtor(zend_file_handle fh) / {{{ */
214	300k	{
215	300k	switch (fh->type) {
216	0	case ZEND_HANDLE_FP:
217	0	if (fh->handle.fp) {
218	0	fclose(fh->handle.fp);
219	0	fh->handle.fp = NULL;
220	0	}
221	0	break;
222	174k	case ZEND_HANDLE_STREAM:
223	174k	if (fh->handle.stream.closer && fh->handle.stream.handle) {
224	106	fh->handle.stream.closer(fh->handle.stream.handle);
225	106	}
226	174k	fh->handle.stream.handle = NULL;
227	174k	break;
228	126k	case ZEND_HANDLE_FILENAME:
229		/* We're only supposed to get here when destructing the used_files hash,
230		* which doesn't really contain open files, but references to their names/paths
231		*/
232	126k	break;
233	300k	}
234	300k	if (fh->opened_path) {
235	72	zend_string_release_ex(fh->opened_path, 0);
236	72	fh->opened_path = NULL;
237	72	}
238	300k	if (fh->buf) {
239	174k	efree(fh->buf);
240	174k	fh->buf = NULL;
241	174k	}
242	300k	if (fh->filename) {
243	300k	zend_string_release(fh->filename);
244	300k	fh->filename = NULL;
245	300k	}
246	300k	}
247		/* }}} */
248
249		/* return int to be compatible with Zend linked list API */
250		static int zend_compare_file_handles(zend_file_handle fh1, zend_file_handle fh2) /* {{{ */
251	127k	{
252	127k	if (fh1->type != fh2->type) {
253	0	return 0;
254	0	}
255	127k	switch (fh1->type) {
256	33	case ZEND_HANDLE_FILENAME:
257	33	return zend_string_equals(fh1->filename, fh2->filename);
258	0	case ZEND_HANDLE_FP:
259	0	return fh1->handle.fp == fh2->handle.fp;
260	127k	case ZEND_HANDLE_STREAM:
261	127k	return fh1->handle.stream.handle == fh2->handle.stream.handle;
262	0	default:
263	0	return 0;
264	127k	}
265	0	return 0;
266	127k	} /* }}} */
267
268		ZEND_API void zend_destroy_file_handle(zend_file_handle file_handle) / {{{ */
269	293k	{
270	293k	if (file_handle->in_list) {
271	127k	zend_llist_del_element(&CG(open_files), file_handle, (int ()(void , void *)) zend_compare_file_handles);
272		/* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
273	127k	file_handle->opened_path = NULL;
274	127k	file_handle->filename = NULL;
275	166k	} else {
276	166k	zend_file_handle_dtor(file_handle);
277	166k	}
278	293k	} /* }}} */
279
280		void zend_stream_init(void) /* {{{ */
281	278k	{
282	278k	zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void ()(void )) zend_file_handle_dtor, 0);
283	278k	} /* }}} */
284
285		void zend_stream_shutdown(void) /* {{{ */
286	278k	{
287	278k	zend_llist_destroy(&CG(open_files));
288	278k	} /* }}} */