Debian Codegraph @

modules/lsp-runtime-lib/src/main/io/NativeFile.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: 7 мар. 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/NativeFile.h>
23 #include <lsp-plug.in/runtime/system.h>
24
25 #if defined(PLATFORM_WINDOWS)
26 #include <windows.h>
27 #include <fileapi.h>
28 #endif /* PLATFORM_WINDOWS */
29
30 #if defined(PLATFORM_UNIX_COMPATIBLE)
31 #include <unistd.h>
32 #include <sys/file.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <errno.h>
36 #endif /* PLATFORM_UNIX_COMPATIBLE */
37
38 #define BAD_FD fhandle_t(-1)
39
40 namespace lsp
41 {
42 namespace io
43 {
44
45 NativeFile::NativeFile()
46 {
47 hFD = BAD_FD;
48 nFlags = 0;
49 }
50
51 NativeFile::~NativeFile()
52 {
53 if (hFD != BAD_FD)
54 {
55 if (nFlags & SF_CLOSE)
56 {
57 #if defined(PLATFORM_WINDOWS)
58 CloseHandle(hFD);
59 #else
60 ::close(hFD);
61 #endif
62 }
63 hFD = BAD_FD;
64 }
65 nFlags = 0;
66 }
67
68 status_t NativeFile::open(const char *path, size_t mode)
69 {
70 if (path == NULL)
71 return set_error(STATUS_BAD_ARGUMENTS);
72
73 LSPString tmp;
74 if (!tmp.set_utf8(path))
75 return set_error(STATUS_NO_MEM);
76 return open(&tmp, mode);
77 }
78
79 #if defined(PLATFORM_WINDOWS)
80 status_t NativeFile::open(const LSPString *path, size_t mode)
81 {
82 if (path == NULL)
83 return set_error(STATUS_BAD_ARGUMENTS);
84
85 fattr_t stat;
86 status_t res = File::stat(path, &stat);
87 if (res == STATUS_OK)
88 {
89 if (stat.type == fattr_t::FT_DIRECTORY)
90 return (mode & FM_CREATE) ? STATUS_ALREADY_EXISTS : STATUS_IS_DIRECTORY;
91 }
92 else if (!(mode & FM_CREATE))
93 return set_error(res);
94
95 int oflags;
96 size_t fflags;
97 size_t cmode;
98 size_t atts = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
99 if (mode & FM_READ)
100 {
101 oflags = (mode & FM_WRITE) ? GENERIC_READ | GENERIC_WRITE : GENERIC_READ;
102 fflags = (mode & FM_WRITE) ? SF_READ | SF_WRITE : SF_READ;
103 }
104 else if (mode & FM_WRITE)
105 {
106 oflags = GENERIC_WRITE;
107 fflags = SF_WRITE;
108 }
109 else
110 return set_error(STATUS_INVALID_VALUE);
111
112 if (mode & FM_CREATE)
113 cmode = (mode & FM_EXCL) ? CREATE_NEW : CREATE_ALWAYS;
114 else if (mode & FM_TRUNC)
115 cmode = TRUNCATE_EXISTING;
116 else
117 cmode = OPEN_EXISTING;
118
119 if (mode & FM_DIRECT)
120 atts |= FILE_FLAG_NO_BUFFERING;
121
122 fhandle_t fd = CreateFileW(path->get_utf16(),
123 oflags,
124 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
125 NULL, cmode, atts, NULL);
126 if (fd == INVALID_HANDLE_VALUE)
127 {
128 DWORD error = GetLastError();
129 res = STATUS_IO_ERROR;
130
131 switch (error)
132 {
133 case ERROR_PATH_NOT_FOUND:
134 case ERROR_FILE_NOT_FOUND:
135 case ERROR_INVALID_ACCESS:
136 case ERROR_INVALID_DRIVE:
137 case ERROR_CANNOT_MAKE:
138 res = STATUS_NOT_FOUND;
139 break;
140 case ERROR_ACCESS_DENIED:
141 res = STATUS_PERMISSION_DENIED;
142 break;
143 case ERROR_TOO_MANY_OPEN_FILES:
144 case ERROR_NOT_ENOUGH_MEMORY:
145 case ERROR_OUTOFMEMORY:
146 res = STATUS_NO_MEM;
147 break;
148 case ERROR_WRITE_PROTECT:
149 res = STATUS_READONLY;
150 break;
151 case ERROR_FILE_EXISTS:
152 case ERROR_ALREADY_EXISTS:
153 res = STATUS_ALREADY_EXISTS;
154 break;
155 case ERROR_DIRECTORY:
156 res = STATUS_IS_DIRECTORY;
157 break;
158 case ERROR_BUFFER_OVERFLOW:
159 res = STATUS_OVERFLOW;
160 break;
161 case ERROR_INVALID_NAME:
162 res = STATUS_INVALID_VALUE;
163 break;
164 default:
165 break;
166 }
167 return set_error(res);
168 }
169
170 // Check that we need to lock the file
171 if (mode & FM_LOCK)
172 {
173 OVERLAPPED ov;
174 ov.Internal = 0;
175 ov.InternalHigh = 0;
176 ov.Offset = 0;
177 ov.OffsetHigh = 0;
178 ov.hEvent = NULL;
179
180 const DWORD flags = (mode & FM_NOWAIT) ? LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY : LOCKFILE_EXCLUSIVE_LOCK;
181 if (!LockFileEx(fd, flags, 0, MAXDWORD, MAXDWORD, &ov))
182 {
183 const DWORD code = GetLastError();
184 status_t res = STATUS_IO_ERROR;
185
186 switch (code)
187 {
188 case ERROR_IO_PENDING: res = STATUS_LOCKED; break;
189 default: break;
190 }
191
192 return set_error(res);
193 }
194 }
195
196 hFD = fd;
197 nFlags = fflags | SF_CLOSE;
198
199 return set_error(STATUS_OK);
200 }
201 #else
202 status_t NativeFile::open(const LSPString *path, size_t mode)
203 {
204 if (path == NULL)
205 return set_error(STATUS_BAD_ARGUMENTS);
206
207 fattr_t stat;
208 if (File::stat(path, &stat) == STATUS_OK)
209 {
210 if (stat.type == fattr_t::FT_DIRECTORY)
211 return (mode & FM_CREATE) ? STATUS_ALREADY_EXISTS : STATUS_NOT_FOUND;
212 }
213
214 int oflags;
215 size_t fflags;
216 if (mode & FM_READ)
217 {
218 oflags = (mode & FM_WRITE) ? O_RDWR : O_RDONLY;
219 fflags = (mode & FM_WRITE) ? SF_READ | SF_WRITE : SF_READ;
220 }
221 else if (mode & FM_WRITE)
222 {
223 oflags = O_WRONLY;
224 fflags = SF_WRITE;
225 }
226 else
227 return set_error(STATUS_INVALID_VALUE);
228 if (mode & FM_CREATE)
229 oflags |= O_CREAT;
230 if (mode & FM_TRUNC)
231 oflags |= O_TRUNC;
232 if (mode & FM_EXCL)
233 oflags |= O_EXCL;
234
235 #if defined(__USE_GNU) && defined(O_DIRECT)
236 if (mode & FM_DIRECT)
237 oflags |= O_DIRECT;
238 #endif /* __USE_GNU */
239
240 fhandle_t fd = ::open(path->get_native(), oflags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
241 if (fd < 0)
242 {
243 const int code = errno;
244 status_t res = STATUS_IO_ERROR;
245
246 switch (code)
247 {
248 case EPERM: case EACCES: res = STATUS_PERMISSION_DENIED; break;
249 case EEXIST: res = STATUS_ALREADY_EXISTS; break;
250 case EINVAL: res = STATUS_INVALID_VALUE; break;
251 case EISDIR: res = STATUS_IS_DIRECTORY; break;
252 case ENAMETOOLONG: res = STATUS_OVERFLOW; break;
253 case ENOENT: res = STATUS_NOT_FOUND; break;
254 case ENOMEM: res = STATUS_NO_MEM; break;
255 case ENOTDIR: res = STATUS_NOT_DIRECTORY; break;
256 case EROFS: res = STATUS_READONLY; break;
257 default: break;
258 }
259
260 return set_error(res);
261 }
262
263 // Check that we need to lock the file
264 if (mode & FM_LOCK)
265 {
266 const int lk_flags = (mode & FM_NOWAIT) ? LOCK_EX | LOCK_NB : LOCK_EX;
267 const int lock_res = flock(fd, lk_flags);
268 if (lock_res != 0)
269 {
270 const int code = errno;
271 ::close(fd);
272
273 status_t res = STATUS_IO_ERROR;
274 switch (code)
275 {
276 case EINTR: res = STATUS_INTERRUPTED; break;
277 case ENOLCK: res = STATUS_NO_MEM; break;
278 case EWOULDBLOCK: res = STATUS_LOCKED; break;
279 default: break;
280 }
281
282 return set_error(res);
283 }
284 }
285
286
287 hFD = fd;
288 nFlags = fflags | SF_CLOSE;
289
290 return set_error(STATUS_OK);
291 }
292 #endif /* PLATFORM_WINDOWS */
293
294 status_t NativeFile::open(const Path *path, size_t mode)
295 {
296 if (path == NULL)
297 return set_error(STATUS_BAD_ARGUMENTS);
298 return open(path->as_string(), mode);
299 }
300
301 status_t NativeFile::wrap(fhandle_t fd, bool close)
302 {
303 // Check state
304 if (hFD != BAD_FD)
305 return set_error(STATUS_BAD_STATE);
306
307 hFD = fd;
308 nFlags = (close) ? SF_READ | SF_WRITE | SF_CLOSE : SF_READ | SF_WRITE;
309 return set_error(STATUS_OK);
310 }
311
312 status_t NativeFile::wrap(fhandle_t fd, size_t mode, bool close)
313 {
314 // Check state
315 if (hFD != BAD_FD)
316 return set_error(STATUS_BAD_STATE);
317
318 size_t flags = (close) ? SF_CLOSE : 0;
319 if (mode & FM_READ)
320 flags |= SF_READ;
321 if (mode & FM_WRITE)
322 flags |= SF_WRITE;
323
324 hFD = fd;
325 nFlags = flags;
326
327 return set_error(STATUS_OK);
328 }
329
330 ssize_t NativeFile::read(void *dst, size_t count)
331 {
332 // Check state
333 if (hFD == BAD_FD)
334 return -set_error(STATUS_BAD_STATE);
335 else if (!(nFlags & SF_READ))
336 return -set_error(STATUS_PERMISSION_DENIED);
337
338 uint8_t *ptr = reinterpret_cast<uint8_t *>(dst);
339 size_t bread = 0;
340 bool eof = false;
341
342 // Perofrm read
343 #ifdef PLATFORM_WINDOWS
344 while (bread < count)
345 {
346 size_t to_read = count - bread;
347 if (to_read >= 0x40000000)
348 to_read = 0x40000000;
349 DWORD n_read = 0;
350
351 if (!ReadFile(hFD, ptr, DWORD(to_read), &n_read, NULL))
352 break;
353 if (n_read <= 0)
354 {
355 eof = true;
356 break;
357 }
358
359 ptr += n_read;
360 bread += n_read;
361 }
362 #else
363 while (bread < count)
364 {
365 size_t to_read = count - bread;
366 size_t n_read = ::read(hFD, ptr, to_read);
367
368 if (n_read <= 0)
369 {
370 eof = true;
371 break;
372 }
373
374 ptr += n_read;
375 bread += n_read;
376 }
377
378 #endif
379 if ((bread > 0) || (count <= 0) || (!eof))
380 {
381 set_error(STATUS_OK);
382 return bread;
383 }
384 return -set_error(STATUS_EOF);
385 }
386
387 ssize_t NativeFile::pread(wsize_t pos, void *dst, size_t count)
388 {
389 // Check state
390 if (hFD == BAD_FD)
391 return -set_error(STATUS_BAD_STATE);
392 else if (!(nFlags & SF_READ))
393 return -set_error(STATUS_PERMISSION_DENIED);
394
395 uint8_t *ptr = reinterpret_cast<uint8_t *>(dst);
396 size_t bread = 0;
397 bool eof = false;
398
399 #ifdef PLATFORM_WINDOWS
400 LARGE_INTEGER off, save;
401 off.QuadPart = 0;
402
403 // Obtrain current file pointer
404 if (!SetFilePointerEx(hFD, off, &save, FILE_CURRENT))
405 return -set_error(STATUS_IO_ERROR);
406
407 // Change file pointer
408 off.QuadPart = pos;
409 if (!SetFilePointerEx(hFD, off, NULL, FILE_BEGIN))
410 return -set_error(STATUS_IO_ERROR);
411
412 // Perform positioned read
413 while (bread < count)
414 {
415 size_t to_read = count - bread;
416 if (to_read >= 0x40000000)
417 to_read = 0x40000000;
418 DWORD n_read = 0;
419
420 if (!ReadFile(hFD, ptr, DWORD(to_read), &n_read, NULL))
421 break;
422 if (n_read <= 0)
423 {
424 eof = true;
425 break;
426 }
427
428 ptr += n_read;
429 bread += n_read;
430 }
431
432 // Restore position
433 if (!SetFilePointerEx(hFD, save, NULL, FILE_BEGIN))
434 return -set_error(STATUS_IO_ERROR);
435 #else
436 // Perform positioned read
437 while (bread < count)
438 {
439 size_t to_read = count - bread;
440 size_t n_read = ::pread(hFD, ptr, to_read, pos);
441
442 if (n_read <= 0)
443 {
444 eof = true;
445 break;
446 }
447
448 ptr += n_read;
449 bread += n_read;
450 pos += n_read;
451 }
452 #endif
453
454 if ((bread > 0) || (count <= 0) || (!eof))
455 {
456 set_error(STATUS_OK);
457 return bread;
458 }
459 return -set_error(STATUS_EOF);
460 }
461
462 ssize_t NativeFile::write(const void *src, size_t count)
463 {
464 // Check state
465 if (hFD == BAD_FD)
466 return -set_error(STATUS_BAD_STATE);
467 else if (!(nFlags & SF_WRITE))
468 return -set_error(STATUS_PERMISSION_DENIED);
469
470 const uint8_t *ptr = reinterpret_cast<const uint8_t *>(src);
471 size_t bwritten = 0;
472
473 // Perform write
474 #ifdef PLATFORM_WINDOWS
475 while (bwritten < count)
476 {
477 size_t to_write = count - bwritten;
478 if (to_write >= 0x40000000)
479 to_write = 0x40000000;
480 DWORD n_written = 0;
481
482 if (!WriteFile(hFD, ptr, to_write, &n_written, NULL))
483 break;
484
485 ptr += n_written;
486 bwritten += n_written;
487 }
488 #else
489 while (bwritten < count)
490 {
491 size_t to_write = count - bwritten;
492 ssize_t n_written = ::write(hFD, ptr, to_write);
493
494 if (n_written <= 0)
495 break;
496
497 ptr += n_written;
498 bwritten += n_written;
499 }
500 #endif
501
502 if ((bwritten > 0) || (count <= 0))
503 {
504 set_error(STATUS_OK);
505 return bwritten;
506 }
507
508 return -set_error(STATUS_IO_ERROR);
509 }
510
511 ssize_t NativeFile::pwrite(wsize_t pos, const void *src, size_t count)
512 {
513 // Check state
514 if (hFD == BAD_FD)
515 return -set_error(STATUS_BAD_STATE);
516 else if (!(nFlags & SF_WRITE))
517 return -set_error(STATUS_PERMISSION_DENIED);
518
519 const uint8_t *ptr = reinterpret_cast<const uint8_t *>(src);
520 size_t bwritten = 0;
521
522 #ifdef PLATFORM_WINDOWS
523 LARGE_INTEGER off, save;
524 off.QuadPart = 0;
525
526 // Obtrain current file pointer
527 if (!SetFilePointerEx(hFD, off, &save, FILE_CURRENT))
528 return -set_error(STATUS_IO_ERROR);
529
530 // Change file pointer
531 off.QuadPart = pos;
532 if (!SetFilePointerEx(hFD, off, NULL, FILE_BEGIN))
533 return -set_error(STATUS_IO_ERROR);
534
535 // Perform positioned write
536 while (bwritten < count)
537 {
538 size_t to_write = count - bwritten;
539 if (to_write >= 0x40000000)
540 to_write = 0x40000000;
541 DWORD n_written = 0;
542
543 if (!WriteFile(hFD, ptr, to_write, &n_written, NULL))
544 break;
545
546 ptr += n_written;
547 bwritten += n_written;
548 }
549
550 // Restore position
551 if (!SetFilePointerEx(hFD, save, NULL, FILE_BEGIN))
552 return -set_error(STATUS_IO_ERROR);
553 #else
554 // Perform positioned write
555 while (bwritten < count)
556 {
557 size_t to_write = count - bwritten;
558 size_t n_written = ::pwrite(hFD, ptr, to_write, pos);
559
560 if (n_written <= 0)
561 break;
562
563 ptr += n_written;
564 bwritten += n_written;
565 pos += n_written;
566 }
567 #endif
568
569 if ((bwritten > 0) || (count <= 0))
570 {
571 set_error(STATUS_OK);
572 return bwritten;
573 }
574
575 return -set_error(STATUS_IO_ERROR);
576 }
577
578 status_t NativeFile::seek(wssize_t pos, size_t type)
579 {
580 if (hFD == BAD_FD)
581 return set_error(STATUS_BAD_STATE);
582
583 #ifdef PLATFORM_WINDOWS
584 DWORD method;
585 LARGE_INTEGER off;
586 switch (type)
587 {
588 case FSK_SET: method = FILE_BEGIN; break;
589 case FSK_CUR: method = FILE_CURRENT; break;
590 case FSK_END: method = FILE_END; break;
591 default: return set_error(STATUS_INVALID_VALUE);
592 }
593 off.QuadPart = pos;
594 if (!SetFilePointerEx(hFD, off, NULL, method))
595 return set_error(STATUS_IO_ERROR);
596 #else
597 int whence;
598 switch (type)
599 {
600 case FSK_SET: whence = SEEK_SET; break;
601 case FSK_CUR: whence = SEEK_CUR; break;
602 case FSK_END: whence = SEEK_END; break;
603 default:
604 return set_error(STATUS_BAD_ARGUMENTS);
605 }
606
607 if (lseek(hFD, pos, whence) < 0)
608 {
609 int code = errno;
610 if (code == ESPIPE)
611 return set_error(STATUS_NOT_SUPPORTED);
612 return set_error(STATUS_IO_ERROR);
613 }
614 #endif /* PLATFORM_WINDOWS */
615
616 return set_error(STATUS_OK);
617 }
618
619 wssize_t NativeFile::position()
620 {
621 if (hFD == BAD_FD)
622 return -set_error(STATUS_BAD_STATE);
623
624 #ifdef PLATFORM_WINDOWS
625 LARGE_INTEGER off, pos;
626 off.QuadPart = 0;
627 if (!SetFilePointerEx(hFD, off, &pos, FILE_CURRENT))
628 return -set_error(STATUS_IO_ERROR);
629 wssize_t result = pos.QuadPart;
630 #else
631 wssize_t result = lseek(hFD, 0, SEEK_CUR);
632 if (result < 0)
633 return -set_error(STATUS_IO_ERROR);
634 #endif /* PLATFORM_WINDOWS */
635
636 return result;
637 }
638
639 wssize_t NativeFile::size()
640 {
641 if (hFD == BAD_FD)
642 return -set_error(STATUS_BAD_STATE);
643
644 #ifdef PLATFORM_WINDOWS
645 LARGE_INTEGER sizebuf;
646 if (!GetFileSizeEx(hFD, &sizebuf))
647 return -set_error(STATUS_IO_ERROR);
648 wssize_t pos = sizebuf.QuadPart;
649 #else
650 struct stat statbuf;
651 if (fstat(hFD, &statbuf) != 0)
652 return -set_error(STATUS_IO_ERROR);
653 wssize_t pos = statbuf.st_size;
654 #endif /* PLATFORM_WINDOWS */
655
656 set_error(STATUS_OK);
657 return pos;
658 }
659
660 status_t NativeFile::stat(fattr_t *attr)
661 {
662 if (hFD == BAD_FD)
663 return -set_error(STATUS_BAD_STATE);
664
665 return set_error(File::stat(hFD, attr));
666 }
667
668 status_t NativeFile::truncate(wsize_t length)
669 {
670 // Check state
671 if (hFD == BAD_FD)
672 return set_error(STATUS_BAD_STATE);
673 else if (!(nFlags & SF_WRITE))
674 return set_error(STATUS_PERMISSION_DENIED);
675
676 #ifdef PLATFORM_WINDOWS
677 LARGE_INTEGER off, pos;
678
679 off.QuadPart = 0;
680 if (!SetFilePointerEx(hFD, off, &pos, FILE_CURRENT))
681 return -set_error(STATUS_IO_ERROR);
682
683 off.QuadPart = length;
684 if (!SetFilePointerEx(hFD, off, NULL, FILE_BEGIN))
685 return -set_error(STATUS_IO_ERROR);
686
687 status_t res = (SetEndOfFile(hFD)) ? STATUS_OK : STATUS_IO_ERROR;
688
689 if (!SetFilePointerEx(hFD, pos, NULL, FILE_BEGIN))
690 res = STATUS_IO_ERROR;
691
692 return set_error(res);
693 #else
694 if (ftruncate(hFD, length) != 0)
695 return set_error(STATUS_IO_ERROR);
696 return set_error(STATUS_OK);
697 #endif /* PLATFORM_WINDOWS */
698 }
699
700 status_t NativeFile::flush()
701 {
702 // Check state
703 if (hFD == BAD_FD)
704 return set_error(STATUS_BAD_STATE);
705 else if (!(nFlags & SF_WRITE))
706 return set_error(STATUS_PERMISSION_DENIED);
707
708 #ifdef PLATFORM_WINDOWS
709 if (!FlushFileBuffers(hFD))
710 return set_error(STATUS_IO_ERROR);
711 #else
712 // Not required
713 // if (fdatasync(hFD) != 0)
714 // return set_error(STATUS_IO_ERROR);
715 #endif /* PLATFORM_WINDOWS */
716
717 return set_error(STATUS_OK);
718 }
719
720 status_t NativeFile::sync()
721 {
722 // Check state
723 if (hFD == BAD_FD)
724 return set_error(STATUS_BAD_STATE);
725 else if (!(nFlags & SF_WRITE))
726 return set_error(STATUS_PERMISSION_DENIED);
727
728 #ifdef PLATFORM_WINDOWS
729 if (!FlushFileBuffers(hFD))
730 return set_error(STATUS_IO_ERROR);
731 #else
732 if (fsync(hFD) != 0)
733 return set_error(STATUS_IO_ERROR);
734 #endif /* PLATFORM_WINDOWS */
735
736 return set_error(STATUS_OK);
737 }
738
739 status_t NativeFile::close()
740 {
741 if (hFD != BAD_FD)
742 {
743 if (nFlags & SF_CLOSE)
744 {
745 #ifdef PLATFORM_WINDOWS
746 if (!CloseHandle(hFD))
747 return set_error(STATUS_IO_ERROR);
748 #else
749 if (::close(hFD) != 0)
750 return set_error(STATUS_IO_ERROR);
751 #endif /* PLATFORM_WINDOWS */
752 }
753
754 hFD = BAD_FD;
755 nFlags = 0;
756 }
757
758 return set_error(STATUS_OK);
759 }
760
761 status_t NativeFile::open_temp(io::Path *path, const char *prefix)
762 {
763 if (prefix == NULL)
764 return open_temp(path, static_cast<LSPString *>(NULL));
765
766 LSPString p;
767 if (!p.set_utf8(prefix))
768 return STATUS_NO_MEM;
769 return open_temp(path, &p);
770 }
771
772 status_t NativeFile::open_temp(LSPString *path, const char *prefix)
773 {
774 if (prefix == NULL)
775 return open_temp(path, static_cast<LSPString *>(NULL));
776
777 LSPString p;
778 if (!p.set_utf8(prefix))
779 return STATUS_NO_MEM;
780 return open_temp(path, &p);
781 }
782
783 status_t NativeFile::open_temp(LSPString *path, const LSPString *prefix)
784 {
785 if (path == NULL)
786 return set_error(STATUS_BAD_ARGUMENTS);
787
788 // Open file
789 io::Path out;
790 status_t res = open_temp(&out, prefix);
791 if (res != STATUS_OK)
792 return res;
793 if ((res = out.get(path)) != STATUS_OK)
794 {
795 // Close the file and remove it on error
796 close();
797 out.remove();
798 }
799
800 return res;
801 }
802
803 status_t NativeFile::open_temp(io::Path *path, const LSPString *prefix)
804 {
805 if (hFD != BAD_FD)
806 return set_error(STATUS_BAD_STATE);
807 else if (path == NULL)
808 return set_error(STATUS_BAD_ARGUMENTS);
809
810 // Make the prefix
811 status_t res;
812 LSPString name;
813 if (prefix != NULL)
814 {
815 if (!name.set(prefix))
816 return STATUS_NO_MEM;
817 if (!name.append('-'))
818 return STATUS_NO_MEM;
819 }
820
821 // Obtain the temporary directory
822 io::Path tempdir;
823 if ((res = system::get_temporary_dir(&tempdir)) != STATUS_OK)
824 return res;
825
826 // Create the file in the loop
827 io::Path full_path;
828 size_t len = name.length();
829
830 while (true)
831 {
832 // Generate the name of the file
833 name.set_length(len);
834 int seed = int(system::get_time_millis()) ^ int(rand());
835 if (!name.fmt_append_ascii("%08x.tmp", seed))
836 return STATUS_NO_MEM;
837 if ((res = full_path.set(&tempdir, &name)) != STATUS_OK)
838 return res;
839
840 // Open temporary file
841 res = open(&full_path, io::File::FM_WRITE_NEW | io::File::FM_EXCL);
842 if (res == STATUS_OK)
843 {
844 full_path.swap(path);
845 return res;
846 }
847 if (res != STATUS_ALREADY_EXISTS)
848 return res;
849 }
850 }
851
852 } /* namespace io */
853 } /* namespace lsp */