Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /* streams working on a disk file */
14 :
15 : #include "monetdb_config.h"
16 : #include "stream.h"
17 : #include "stream_internal.h"
18 : #include "mutils.h"
19 :
20 :
21 : /* ------------------------------------------------------------------ */
22 : /* streams working on a disk file */
23 :
24 :
25 : /* should be static but isn't because there are some other parts of the
26 : * library that have a specific fast path for stdio streams.
27 : */
28 : ssize_t
29 26725814 : file_read(stream *restrict s, void *restrict buf, size_t elmsize, size_t cnt)
30 : {
31 26725814 : FILE *fp = (FILE *) s->stream_data.p;
32 26725814 : size_t rc = 0;
33 :
34 26725814 : if (fp == NULL) {
35 0 : mnstr_set_error(s, MNSTR_READ_ERROR, "file ended");
36 0 : return -1;
37 : }
38 :
39 26725814 : if (elmsize && cnt) {
40 26725814 : errno = 0;
41 26725814 : if ((rc = fread(buf, elmsize, cnt, fp)) == 0 && ferror(fp)) {
42 0 : mnstr_set_error_errno(s, errno == EINTR ? MNSTR_INTERRUPT : MNSTR_READ_ERROR, "read error");
43 0 : return -1;
44 : }
45 26725814 : s->eof |= rc == 0 && feof(fp);
46 : }
47 26725814 : return (ssize_t) rc;
48 : }
49 :
50 :
51 : static ssize_t
52 40242245 : file_write(stream *restrict s, const void *restrict buf, size_t elmsize, size_t cnt)
53 : {
54 40242245 : FILE *fp = (FILE *) s->stream_data.p;
55 :
56 40242245 : if (fp == NULL) {
57 0 : mnstr_set_error(s, MNSTR_WRITE_ERROR, "file ended");
58 0 : return -1;
59 : }
60 :
61 40242245 : if (elmsize && cnt) {
62 40239493 : size_t rc = fwrite(buf, elmsize, cnt, fp);
63 :
64 40239493 : if (rc != cnt) {
65 : // only happens if fwrite encountered an error.
66 0 : mnstr_set_error_errno(s, MNSTR_WRITE_ERROR, "write error");
67 0 : return -1;
68 : }
69 40239493 : return (ssize_t) rc;
70 : }
71 2752 : return (ssize_t) cnt;
72 : }
73 :
74 :
75 : static void
76 57034 : file_close(stream *s)
77 : {
78 57034 : FILE *fp = (FILE *) s->stream_data.p;
79 :
80 57034 : if (fp == NULL)
81 : return;
82 28629 : if (fp != stdin && fp != stdout && fp != stderr) {
83 27572 : if (s->name && *s->name == '|')
84 0 : pclose(fp);
85 : else
86 27572 : fclose(fp);
87 1057 : } else if (!s->readonly)
88 606 : fflush(fp);
89 28629 : s->stream_data.p = NULL;
90 : }
91 :
92 :
93 : static void
94 28629 : file_destroy(stream *s)
95 : {
96 28629 : file_close(s);
97 28629 : destroy_stream(s);
98 28629 : }
99 :
100 :
101 : static void
102 0 : file_clrerr(stream *s)
103 : {
104 0 : FILE *fp = (FILE *) s->stream_data.p;
105 :
106 0 : if (fp)
107 0 : clearerr(fp);
108 0 : }
109 :
110 :
111 : static int
112 170185 : file_flush(stream *s, mnstr_flush_level flush_level)
113 : {
114 170185 : FILE *fp = (FILE *) s->stream_data.p;
115 :
116 170185 : if (fp == NULL || (!s->readonly && fflush(fp) < 0)) {
117 0 : mnstr_set_error_errno(s, MNSTR_WRITE_ERROR, "flush error");
118 0 : return -1;
119 : }
120 : (void) flush_level;
121 : return 0;
122 : }
123 :
124 :
125 : static int
126 33 : file_fsync(stream *s)
127 : {
128 :
129 33 : FILE *fp = (FILE *) s->stream_data.p;
130 :
131 33 : if (fp == NULL ||
132 33 : (!s->readonly
133 : #ifdef NATIVE_WIN32
134 : && _commit(fileno(fp)) < 0
135 : #else
136 : #ifdef HAVE_FDATASYNC
137 33 : && fdatasync(fileno(fp)) < 0
138 : #else
139 : #ifdef HAVE_FSYNC
140 : && fsync(fileno(fp)) < 0
141 : #endif
142 : #endif
143 : #endif
144 : )) {
145 0 : mnstr_set_error(s, MNSTR_WRITE_ERROR, "fsync failed");
146 0 : return -1;
147 : }
148 : return 0;
149 : }
150 :
151 :
152 : static int
153 0 : file_fgetpos(stream *restrict s, fpos_t *restrict p)
154 : {
155 0 : FILE *fp = (FILE *) s->stream_data.p;
156 :
157 0 : if (fp == NULL || p == NULL)
158 : return -1;
159 0 : return fgetpos(fp, p) ? -1 : 0;
160 : }
161 :
162 :
163 : static int
164 0 : file_fsetpos(stream *restrict s, fpos_t *restrict p)
165 : {
166 0 : FILE *fp = (FILE *) s->stream_data.p;
167 :
168 0 : if (fp == NULL || p == NULL)
169 : return -1;
170 0 : return fsetpos(fp, p) ? -1 : 0;
171 : }
172 :
173 :
174 : stream *
175 27749 : open_stream(const char *restrict filename, const char *restrict flags)
176 : {
177 27749 : stream *s;
178 27749 : FILE *fp;
179 27749 : fpos_t pos;
180 27749 : char buf[UTF8BOMLENGTH + 1];
181 :
182 27749 : if ((s = create_stream(filename)) == NULL)
183 : return NULL;
184 : #ifdef NATIVE_WIN32
185 : {
186 : wchar_t *wfname = utf8toutf16(filename);
187 : wchar_t *wflags = utf8toutf16(flags);
188 : static_assert(SIZEOF_WCHAR_T == 2, "wchar_t on Windows expected to be 2 bytes");
189 : if (wfname != NULL && wflags != NULL)
190 : fp = _wfopen(wfname, wflags);
191 : else
192 : fp = NULL;
193 : if (wfname)
194 : free(wfname);
195 : if (wflags)
196 : free(wflags);
197 : }
198 : #else
199 27749 : fp = fopen(filename, flags);
200 : #endif
201 27749 : if (fp == NULL) {
202 161 : mnstr_set_open_error(filename, errno, "open failed");
203 161 : destroy_stream(s);
204 161 : return NULL;
205 : }
206 27588 : s->readonly = flags[0] == 'r';
207 27588 : s->binary = flags[1] == 'b';
208 27588 : s->read = file_read;
209 27588 : s->write = file_write;
210 27588 : s->close = file_close;
211 27588 : s->destroy = file_destroy;
212 27588 : s->clrerr = file_clrerr;
213 27588 : s->flush = file_flush;
214 27588 : s->fsync = file_fsync;
215 27588 : s->fgetpos = file_fgetpos;
216 27588 : s->fsetpos = file_fsetpos;
217 27588 : s->stream_data.p = (void *) fp;
218 : /* if a text file is opened for reading, and it starts with
219 : * the UTF-8 encoding of the Unicode Byte Order Mark, skip the
220 : * mark, and mark the stream as being a UTF-8 stream */
221 27588 : if (flags[0] == 'r' && flags[1] != 'b' && fgetpos(fp, &pos) == 0) {
222 0 : if (file_read(s, buf, 1, UTF8BOMLENGTH) == UTF8BOMLENGTH &&
223 0 : strncmp(buf, UTF8BOM, UTF8BOMLENGTH) == 0)
224 0 : s->isutf8 = true;
225 0 : else if (fsetpos(fp, &pos) != 0) {
226 : /* unlikely: we couldn't seek the file back */
227 0 : fclose(fp);
228 0 : destroy_stream(s);
229 0 : return NULL;
230 : }
231 : }
232 : return s;
233 : }
234 :
235 : stream *
236 1111 : file_stream(const char *name)
237 : {
238 1111 : stream *s;
239 :
240 1111 : if ((s = create_stream(name)) == NULL)
241 : return NULL;
242 1111 : s->read = file_read;
243 1111 : s->write = file_write;
244 1111 : s->close = file_close;
245 1111 : s->destroy = file_destroy;
246 1111 : s->flush = file_flush;
247 1111 : s->fsync = file_fsync;
248 1111 : s->fgetpos = file_fgetpos;
249 1111 : s->fsetpos = file_fsetpos;
250 1111 : return s;
251 : }
252 :
253 : stream *
254 455 : file_rstream(FILE *restrict fp, bool binary, const char *restrict name)
255 : {
256 455 : stream *s;
257 :
258 455 : if (fp == NULL)
259 : return NULL;
260 : #ifdef STREAM_DEBUG
261 : fprintf(stderr, "file_rstream %s\n", name);
262 : #endif
263 455 : if ((s = file_stream(name)) == NULL)
264 : return NULL;
265 455 : s->binary = binary;
266 455 : s->stream_data.p = (void *) fp;
267 455 : return s;
268 : }
269 :
270 : stream *
271 656 : file_wstream(FILE *restrict fp, bool binary, const char *restrict name)
272 : {
273 656 : stream *s;
274 :
275 656 : if (fp == NULL)
276 : return NULL;
277 : #ifdef STREAM_DEBUG
278 : fprintf(stderr, "file_wstream %s\n", name);
279 : #endif
280 656 : if ((s = file_stream(name)) == NULL)
281 : return NULL;
282 656 : s->readonly = false;
283 656 : s->binary = binary;
284 656 : s->stream_data.p = (void *) fp;
285 656 : return s;
286 : }
287 :
288 :
289 : stream *
290 455 : stdin_rastream(void)
291 : {
292 455 : const char name[] = "<stdin>";
293 : // Make an attempt to skip a BOM marker.
294 : // It would be nice to integrate this with with the BOM removal code
295 : // in text_stream.c but that is complicated. In text_stream,
296 455 : struct stat stb;
297 455 : if (fstat(fileno(stdin), &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFREG) {
298 10 : fpos_t pos;
299 10 : if (fgetpos(stdin, &pos) == 0) {
300 10 : char bytes[UTF8BOMLENGTH];
301 10 : size_t nread = fread(bytes, 1, UTF8BOMLENGTH, stdin);
302 10 : if (nread != 3 || memcmp(bytes, UTF8BOM, UTF8BOMLENGTH) != 0) {
303 : // not a BOM, rewind
304 10 : if (nread > 0 && fsetpos(stdin, &pos) != 0) {
305 : // oops, bytes have been read but we can't rewind
306 0 : mnstr_set_error_errno(NULL, MNSTR_OPEN_ERROR, "while rewinding after checking for byte order mark");
307 0 : return NULL;
308 : }
309 : }
310 : }
311 : }
312 :
313 : #ifdef _MSC_VER
314 : return win_console_in_stream(name);
315 : #else
316 455 : return file_rstream(stdin, false, name);
317 : #endif
318 : }
319 :
320 : stream *
321 519 : stdout_wastream(void)
322 : {
323 519 : const char name[] = "<stdout>";
324 : #ifdef _MSC_VER
325 : if (isatty(fileno(stdout)))
326 : return win_console_out_stream(name);
327 : #endif
328 519 : return file_wstream(stdout, false, name);
329 : }
330 :
331 : stream *
332 137 : stderr_wastream(void)
333 : {
334 137 : const char name[] = "<stderr>";
335 : #ifdef _MSC_VER
336 : if (isatty(fileno(stderr)))
337 : return win_console_out_stream(name);
338 : #endif
339 137 : return file_wstream(stderr, false, name);
340 : }
341 :
342 : /* some lower-level access functions */
343 : FILE *
344 71022 : getFile(stream *s)
345 : {
346 71025 : for (; s != NULL; s = s->inner) {
347 : #ifdef _MSC_VER
348 : if (s->read == console_read)
349 : return stdin;
350 : if (s->write == console_write)
351 : return stdout;
352 : #endif
353 71025 : if (s->read == file_read)
354 71022 : return (FILE *) s->stream_data.p;
355 : }
356 :
357 : return NULL;
358 : }
359 :
360 : int
361 300 : getFileNo(stream *s)
362 : {
363 300 : FILE *f;
364 :
365 300 : f = getFile(s);
366 300 : if (f == NULL)
367 : return -1;
368 300 : return fileno(f);
369 : }
370 :
371 : size_t
372 0 : getFileSize(stream *s)
373 : {
374 0 : struct stat stb;
375 0 : int fd = getFileNo(s);
376 :
377 0 : if (fd >= 0 && fstat(fd, &stb) == 0)
378 0 : return (size_t) stb.st_size;
379 : return 0; /* unknown */
380 : }
381 :
382 : int
383 0 : file_remove(const char *filename)
384 : {
385 0 : int rc = -1;
386 :
387 : #ifdef NATIVE_WIN32
388 : wchar_t *wfname = utf8toutf16(filename);
389 : if (wfname != NULL) {
390 : rc = _wremove(wfname);
391 : free(wfname);
392 : }
393 : #else
394 0 : rc = remove(filename);
395 : #endif
396 0 : return rc;
397 : }
|
