Debian Codegraph @

modules/lsp-runtime-lib/src/main/io/StdioFile.cpp

raw
1 /*
2 * Copyright (C) 2026 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2026 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 6 мар. 2019 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/io/StdioFile.h>
23
24 #include <errno.h>
25 #include <sys/file.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28
29 #ifdef PLATFORM_WINDOWS
30 #include <windows.h>
31 #endif /* PLATFORM_WINDOWS */
32
33 namespace lsp
34 {
35 namespace io
36 {
37 StdioFile::StdioFile()
38 {
39 pFD = NULL;
40 nFlags = 0;
41 }
42
43 StdioFile::~StdioFile()
44 {
45 if (pFD != NULL)
46 {
47 if (nFlags & SF_CLOSE)
48 fclose(pFD);
49 pFD = NULL;
50 }
51 nFlags = 0;
52 }
53
54 status_t StdioFile::open(const char *path, size_t mode)
55 {
56 if (path == NULL)
57 return set_error(STATUS_BAD_ARGUMENTS);
58
59 LSPString tmp;
60 if (!tmp.set_utf8(path))
61 return set_error(STATUS_NO_MEM);
62 return open(&tmp, mode);
63 }
64
65 status_t StdioFile::open(const LSPString *path, size_t mode)
66 {
67 const char *fmode;
68 size_t flags;
69
70 // Check state
71 if (pFD != NULL)
72 return set_error(STATUS_BAD_STATE);
73
74 // Determine mode
75 if (mode & FM_READ)
76 {
77 if (mode & FM_WRITE)
78 {
79 flags = SF_READ | SF_WRITE;
80 if (mode & (FM_CREATE | FM_TRUNC))
81 fmode = "wb+";
82 else
83 fmode = "rb+";
84 }
85 else // "r"
86 {
87 flags = SF_READ;
88 fmode = "rb";
89 }
90 }
91 else if (mode & FM_WRITE)
92 {
93 flags = SF_WRITE;
94 if (mode & (FM_CREATE | FM_TRUNC))
95 fmode = "wb";
96 else
97 fmode = "rb+";
98 }
99 else
100 return set_error(STATUS_INVALID_VALUE);
101
102 // Open file
103 FILE *fd = fopen(path->get_native(), fmode);
104 if (fd == NULL)
105 {
106 int code = errno;
107 switch (code)
108 {
109 case EINVAL:
110 return set_error(STATUS_BAD_ARGUMENTS);
111 default:
112 return set_error(STATUS_UNKNOWN_ERR);
113 }
114 }
115
116 // Check that we need to lock the file
117 if (mode & FM_LOCK)
118 {
119 #ifdef PLATFORM_WINDOWS
120 const int ifd = _fileno(fd);
121 const HANDLE hfd = reinterpret_cast<HANDLE>(_get_osfhandle(ifd));
122
123 OVERLAPPED ov;
124 ov.Internal = 0;
125 ov.InternalHigh = 0;
126 ov.Offset = 0;
127 ov.OffsetHigh = 0;
128 ov.hEvent = NULL;
129
130 const DWORD flags = (mode & FM_NOWAIT) ? LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY : LOCKFILE_EXCLUSIVE_LOCK;
131 if (!LockFileEx(hfd, flags, 0, MAXDWORD, MAXDWORD, &ov))
132 {
133 const DWORD code = GetLastError();
134 fclose(fd);
135
136 status_t res = STATUS_IO_ERROR;
137 switch (code)
138 {
139 case ERROR_IO_PENDING: res = STATUS_LOCKED; break;
140 default: break;
141 }
142
143 return set_error(res);
144 }
145 #else
146 const int lk_flags = (mode & FM_NOWAIT) ? LOCK_EX | LOCK_NB : LOCK_EX;
147 const int lock_res = flock(fileno(fd), lk_flags);
148 if (lock_res != 0)
149 {
150 const int code = errno;
151 fclose(fd);
152
153 status_t res = STATUS_IO_ERROR;
154 switch (code)
155 {
156 case EINTR: res = STATUS_INTERRUPTED; break;
157 case ENOLCK: res = STATUS_NO_MEM; break;
158 case EWOULDBLOCK: res = STATUS_LOCKED; break;
159 default: break;
160 }
161
162 return set_error(res);
163 }
164 #endif /* PLATFORM_WINDOWS */
165 }
166
167 // Update state
168 pFD = fd;
169 nFlags = flags | SF_CLOSE;
170
171 return set_error(STATUS_OK);
172 }
173
174 status_t StdioFile::open(const Path *path, size_t mode)
175 {
176 if (path == NULL)
177 return set_error(STATUS_BAD_ARGUMENTS);
178 return open(path->as_string(), mode);
179 }
180
181 status_t StdioFile::wrap(FILE *fd, bool close)
182 {
183 // Check state
184 if (fd == NULL)
185 return set_error(STATUS_BAD_ARGUMENTS);
186 else if (pFD != NULL)
187 return set_error(STATUS_BAD_STATE);
188
189 pFD = fd;
190 nFlags = (close) ? SF_READ | SF_WRITE | SF_CLOSE : SF_READ | SF_WRITE;
191 return set_error(STATUS_OK);
192 }
193
194 status_t StdioFile::wrap(FILE *fd, size_t mode, bool close)
195 {
196 // Check state
197 if (fd == NULL)
198 return set_error(STATUS_BAD_ARGUMENTS);
199 else if (pFD != NULL)
200 return set_error(STATUS_BAD_STATE);
201
202 size_t flags = (close) ? SF_CLOSE : 0;
203 if (mode & FM_READ)
204 flags |= SF_READ;
205 if (mode & FM_WRITE)
206 flags |= SF_WRITE;
207
208 pFD = fd;
209 nFlags = flags;
210
211 return set_error(STATUS_OK);
212 }
213
214 ssize_t StdioFile::read(void *dst, size_t count)
215 {
216 // Check state
217 if (pFD == NULL)
218 return -set_error(STATUS_BAD_STATE);
219 else if (!(nFlags & SF_READ))
220 return -set_error(STATUS_PERMISSION_DENIED);
221
222 // Perform read
223 uint8_t *ptr = reinterpret_cast<uint8_t *>(dst);
224 size_t bread = 0;
225 bool eof = false;
226
227 while (bread < count)
228 {
229 size_t to_read = count - bread;
230 size_t n_read = fread(ptr, 1, to_read, pFD);
231
232 if (n_read <= 0)
233 {
234 eof = feof(pFD);
235 break;
236 }
237
238 ptr += n_read;
239 bread += n_read;
240 }
241
242 if ((bread > 0) || (count <= 0) || (!eof))
243 {
244 set_error(STATUS_OK);
245 return bread;
246 }
247 return -set_error(STATUS_EOF);
248 }
249
250 ssize_t StdioFile::pread(wsize_t pos, void *dst, size_t count)
251 {
252 // Check state
253 if (pFD == NULL)
254 return -set_error(STATUS_BAD_STATE);
255 else if (!(nFlags & SF_READ))
256 return -set_error(STATUS_PERMISSION_DENIED);
257
258 // Store previous position
259 wssize_t save = ftello(pFD);
260 if (save < 0)
261 return -set_error(STATUS_IO_ERROR);
262
263 // Update position
264 if (pos != wsize_t(save))
265 {
266 if (fseeko(pFD, pos, SEEK_SET) != 0)
267 return -set_error(STATUS_IO_ERROR);
268 }
269
270 // Perform read
271 uint8_t *ptr = reinterpret_cast<uint8_t *>(dst);
272 size_t bread = 0;
273 bool eof = false;
274
275 while (bread < count)
276 {
277 size_t to_read = count - bread;
278 size_t n_read = fread(ptr, 1, to_read, pFD);
279
280 if (n_read <= 0)
281 {
282 eof = feof(pFD);
283 break;
284 }
285
286 ptr += n_read;
287 bread += n_read;
288 }
289
290 // Restore position
291 if (pos != wsize_t(save))
292 {
293 if (fseeko(pFD, save, SEEK_SET) != 0)
294 return -set_error(STATUS_IO_ERROR);
295 }
296
297 if ((bread > 0) || (count <= 0) || (!eof))
298 {
299 set_error(STATUS_OK);
300 return bread;
301 }
302 return -set_error(STATUS_EOF);
303 }
304
305 ssize_t StdioFile::write(const void *src, size_t count)
306 {
307 // Check state
308 if (pFD == NULL)
309 return -set_error(STATUS_BAD_STATE);
310 else if (!(nFlags & SF_WRITE))
311 return -set_error(STATUS_PERMISSION_DENIED);
312
313 // Perform write
314 const uint8_t *ptr = reinterpret_cast<const uint8_t *>(src);
315 size_t bwritten = 0;
316
317 while (bwritten < count)
318 {
319 size_t to_write = count - bwritten;
320 size_t n_written= fwrite(ptr, 1, to_write, pFD);
321
322 if (n_written <= 0)
323 break;
324
325 ptr += n_written;
326 bwritten += n_written;
327 }
328
329 if ((bwritten > 0) || (count <= 0))
330 {
331 set_error(STATUS_OK);
332 return bwritten;
333 }
334 return -set_error(STATUS_IO_ERROR);
335 }
336
337 ssize_t StdioFile::pwrite(wsize_t pos, const void *src, size_t count)
338 {
339 // Check state
340 if (pFD == NULL)
341 return -set_error(STATUS_BAD_STATE);
342 else if (!(nFlags & SF_WRITE))
343 return -set_error(STATUS_PERMISSION_DENIED);
344
345 // Store previous position
346 wssize_t save = ftello(pFD);
347 if (save < 0)
348 return -set_error(STATUS_IO_ERROR);
349
350 // Update position
351 if (pos != wsize_t(save))
352 {
353 if (fseeko(pFD, pos, SEEK_SET) != 0)
354 return -set_error(STATUS_IO_ERROR);
355 }
356
357 // Perform write
358 const uint8_t *ptr = reinterpret_cast<const uint8_t *>(src);
359 size_t bwritten = 0;
360
361 while (bwritten < count)
362 {
363 size_t to_write = count - bwritten;
364 size_t n_written= fwrite(ptr, 1, to_write, pFD);
365
366 if (n_written <= 0)
367 break;
368
369 ptr += n_written;
370 bwritten += n_written;
371 }
372
373 // Restore position
374 if (pos != wsize_t(save))
375 {
376 if (fseeko(pFD, save, SEEK_SET) != 0)
377 return -set_error(STATUS_IO_ERROR);
378 }
379
380 if ((bwritten > 0) || (count <= 0))
381 {
382 set_error(STATUS_OK);
383 return bwritten;
384 }
385
386 return -set_error(STATUS_IO_ERROR);
387 }
388
389 status_t StdioFile::seek(wssize_t pos, size_t type)
390 {
391 if (pFD == NULL)
392 return set_error(STATUS_BAD_STATE);
393
394 int whence;
395 switch (type)
396 {
397 case FSK_SET: whence = SEEK_SET; break;
398 case FSK_CUR: whence = SEEK_CUR; break;
399 case FSK_END: whence = SEEK_END; break;
400 default:
401 return set_error(STATUS_BAD_ARGUMENTS);
402 }
403
404 if (::fseeko(pFD, pos, whence) != 0)
405 {
406 int code = errno;
407 if (code == ESPIPE)
408 return set_error(STATUS_NOT_SUPPORTED);
409 return set_error(STATUS_IO_ERROR);
410 }
411
412 return STATUS_OK;
413 }
414
415 wssize_t StdioFile::position()
416 {
417 if (pFD == NULL)
418 return -set_error(STATUS_BAD_STATE);
419
420 wssize_t pos = ftello(pFD);
421 if (pos < 0)
422 return -set_error(STATUS_IO_ERROR);
423 set_error(STATUS_OK);
424 return pos;
425 }
426
427 wssize_t StdioFile::size()
428 {
429 if (pFD == NULL)
430 return -set_error(STATUS_BAD_STATE);
431
432 #ifdef PLATFORM_WINDOWS
433 LARGE_INTEGER sizebuf;
434 int fd = _fileno(pFD);
435 intptr_t hfd = _get_osfhandle(fd);
436 if (!GetFileSizeEx(reinterpret_cast<HANDLE>(hfd), &sizebuf))
437 return -set_error(STATUS_IO_ERROR);
438 wssize_t pos = sizebuf.QuadPart;
439 #else
440 struct stat statbuf;
441 if (fstat(fileno(pFD), &statbuf) != 0)
442 return -set_error(STATUS_IO_ERROR);
443 wssize_t pos = statbuf.st_size;
444 #endif
445
446 set_error(STATUS_OK);
447 return pos;
448 }
449
450 status_t StdioFile::stat(fattr_t *attr)
451 {
452 if (pFD == NULL)
453 return -set_error(STATUS_BAD_STATE);
454 return set_error(File::stat(pFD, attr));
455 }
456
457 status_t StdioFile::truncate(wsize_t length)
458 {
459 // Check state
460 if (pFD == NULL)
461 return set_error(STATUS_BAD_STATE);
462 else if (!(nFlags & SF_WRITE))
463 return set_error(STATUS_PERMISSION_DENIED);
464
465 if (fflush(pFD) != 0)
466 return set_error(STATUS_IO_ERROR);
467 if (ftruncate(fileno(pFD), length) != 0)
468 return set_error(STATUS_IO_ERROR);
469 return set_error(STATUS_OK);
470 }
471
472 status_t StdioFile::flush()
473 {
474 // Check state
475 if (pFD == NULL)
476 return set_error(STATUS_BAD_STATE);
477 else if (!(nFlags & SF_WRITE))
478 return set_error(STATUS_PERMISSION_DENIED);
479
480 if (fflush(pFD) != 0)
481 return set_error(STATUS_IO_ERROR);
482 return set_error(STATUS_OK);
483 }
484
485 status_t StdioFile::sync()
486 {
487 // Check state
488 if (pFD == NULL)
489 return set_error(STATUS_BAD_STATE);
490 else if (!(nFlags & SF_WRITE))
491 return set_error(STATUS_PERMISSION_DENIED);
492
493 if (fflush(pFD) != 0)
494 return set_error(STATUS_IO_ERROR);
495 #ifdef PLATFORM_WINDOWS
496 if (_commit(_fileno(pFD)) != 0)
497 return set_error(STATUS_IO_ERROR);
498 #else
499 if (fsync(fileno(pFD)) != 0)
500 return set_error(STATUS_IO_ERROR);
501 #endif
502
503 return set_error(STATUS_OK);
504 }
505
506 status_t StdioFile::close()
507 {
508 if (pFD != NULL)
509 {
510 if (nFlags & SF_CLOSE)
511 {
512 if (fclose(pFD) != 0)
513 return set_error(STATUS_IO_ERROR);
514 }
515
516 pFD = NULL;
517 nFlags = 0;
518 }
519
520 return set_error(STATUS_OK);
521 }
522
523 } /* namespace io */
524 } /* namespace lsp */