Coverage Report

Created: 2025-06-13 06:43

/src/php-src/Zend/zend_stream.c
Line
Count
Source (jump to first uncovered line)
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
69
{
56
69
  ZEND_ASSERT(file_handle->type == ZEND_HANDLE_STREAM);
57
69
  if (file_handle->handle.stream.isatty) {
58
0
    return 0;
59
0
  }
60
69
  return file_handle->handle.stream.fsizer(file_handle->handle.stream.handle);
61
69
} /* }}} */
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
156k
ZEND_API void zend_stream_init_filename(zend_file_handle *handle, const char *filename) {
71
156k
  memset(handle, 0, sizeof(zend_file_handle));
72
156k
  handle->type = ZEND_HANDLE_FILENAME;
73
156k
  handle->filename = filename ? zend_string_init(filename, strlen(filename), 0) : NULL;
74
156k
}
75
76
182k
ZEND_API void zend_stream_init_filename_ex(zend_file_handle *handle, zend_string *filename) {
77
182k
  memset(handle, 0, sizeof(zend_file_handle));
78
182k
  handle->type = ZEND_HANDLE_FILENAME;
79
182k
  handle->filename = zend_string_copy(filename);
80
182k
}
81
82
ZEND_API zend_result zend_stream_open(zend_file_handle *handle) /* {{{ */
83
746
{
84
746
  zend_string *opened_path;
85
86
746
  ZEND_ASSERT(handle->type == ZEND_HANDLE_FILENAME);
87
746
  if (zend_stream_open_function) {
88
746
    return zend_stream_open_function(handle);
89
746
  }
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
81
{
111
81
  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
81
  return file_handle->handle.stream.reader(file_handle->handle.stream.handle, buf, len);
125
81
} /* }}} */
126
127
ZEND_API zend_result zend_stream_fixup(zend_file_handle *file_handle, char **buf, size_t *len) /* {{{ */
128
144k
{
129
144k
  size_t file_size;
130
131
144k
  if (file_handle->buf) {
132
143k
    *buf = file_handle->buf;
133
143k
    *len = file_handle->len;
134
143k
    return SUCCESS;
135
143k
  }
136
137
630
  if (file_handle->type == ZEND_HANDLE_FILENAME) {
138
625
    if (zend_stream_open(file_handle) == FAILURE) {
139
561
      return FAILURE;
140
561
    }
141
625
  }
142
143
69
  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
69
  file_size = zend_stream_fsize(file_handle);
157
69
  if (file_size == (size_t)-1) {
158
0
    return FAILURE;
159
0
  }
160
161
69
  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
33
    while ((read = zend_stream_read(file_handle, *buf + size, file_size - size)) > 0) {
166
12
      size += read;
167
12
    }
168
21
    if (read < 0) {
169
2
      efree(*buf);
170
2
      return FAILURE;
171
2
    }
172
19
    file_handle->buf = *buf;
173
19
    file_handle->len = size;
174
48
  } else {
175
48
    size_t size = 0, remain = 4*1024;
176
48
    ssize_t read;
177
48
    *buf = emalloc(remain);
178
179
48
    while ((read = zend_stream_read(file_handle, *buf + size, remain)) > 0) {
180
0
      size   += read;
181
0
      remain -= read;
182
183
0
      if (remain == 0) {
184
0
        *buf   = safe_erealloc(*buf, size, 2, 0);
185
0
        remain = size;
186
0
      }
187
0
    }
188
48
    if (read < 0) {
189
16
      efree(*buf);
190
16
      return FAILURE;
191
16
    }
192
193
32
    file_handle->len = size;
194
32
    if (size && remain < ZEND_MMAP_AHEAD) {
195
0
      *buf = safe_erealloc(*buf, size, 1, ZEND_MMAP_AHEAD);
196
0
    }
197
32
    file_handle->buf = *buf;
198
32
  }
199
200
51
  if (file_handle->len == 0) {
201
35
    *buf = erealloc(*buf, ZEND_MMAP_AHEAD);
202
35
    file_handle->buf = *buf;
203
35
  }
204
205
51
  memset(file_handle->buf + file_handle->len, 0, ZEND_MMAP_AHEAD);
206
207
51
  *buf = file_handle->buf;
208
51
  *len = file_handle->len;
209
210
51
  return SUCCESS;
211
69
} /* }}} */
212
213
static void zend_file_handle_dtor(zend_file_handle *fh) /* {{{ */
214
339k
{
215
339k
  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
157k
    case ZEND_HANDLE_STREAM:
223
157k
      if (fh->handle.stream.closer && fh->handle.stream.handle) {
224
65
        fh->handle.stream.closer(fh->handle.stream.handle);
225
65
      }
226
157k
      fh->handle.stream.handle = NULL;
227
157k
      break;
228
182k
    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
182k
      break;
233
339k
  }
234
339k
  if (fh->opened_path) {
235
42
    zend_string_release_ex(fh->opened_path, 0);
236
42
    fh->opened_path = NULL;
237
42
  }
238
339k
  if (fh->buf) {
239
157k
    efree(fh->buf);
240
157k
    fh->buf = NULL;
241
157k
  }
242
339k
  if (fh->filename) {
243
339k
    zend_string_release(fh->filename);
244
339k
    fh->filename = NULL;
245
339k
  }
246
339k
}
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
138k
{
252
138k
  if (fh1->type != fh2->type) {
253
0
    return 0;
254
0
  }
255
138k
  switch (fh1->type) {
256
553
    case ZEND_HANDLE_FILENAME:
257
553
      return zend_string_equals(fh1->filename, fh2->filename);
258
0
    case ZEND_HANDLE_FP:
259
0
      return fh1->handle.fp == fh2->handle.fp;
260
137k
    case ZEND_HANDLE_STREAM:
261
137k
      return fh1->handle.stream.handle == fh2->handle.stream.handle;
262
0
    default:
263
0
      return 0;
264
138k
  }
265
0
  return 0;
266
138k
} /* }}} */
267
268
ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle) /* {{{ */
269
333k
{
270
333k
  if (file_handle->in_list) {
271
138k
    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
138k
    file_handle->opened_path = NULL;
274
138k
    file_handle->filename = NULL;
275
195k
  } else {
276
195k
    zend_file_handle_dtor(file_handle);
277
195k
  }
278
333k
} /* }}} */
279
280
void zend_stream_init(void) /* {{{ */
281
300k
{
282
300k
  zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) zend_file_handle_dtor, 0);
283
300k
} /* }}} */
284
285
void zend_stream_shutdown(void) /* {{{ */
286
300k
{
287
300k
  zend_llist_destroy(&CG(open_files));
288
300k
} /* }}} */