Debian Codegraph @

modules/lsp-runtime-lib/src/main/ipc/Process.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: 24 июл. 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/common/debug.h>
23 #include <lsp-plug.in/ipc/Process.h>
24 #include <lsp-plug.in/io/OutFileStream.h>
25 #include <lsp-plug.in/io/InFileStream.h>
26 #include <lsp-plug.in/runtime/system.h>
27
28 #include <unistd.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <time.h>
32
33 #if defined(PLATFORM_WINDOWS)
34 #include <windows.h>
35 #include <processthreadsapi.h>
36 #include <namedpipeapi.h>
37 #include <shlwapi.h>
38 #include <synchapi.h>
39 #include <processenv.h>
40 #else
41 #include <spawn.h>
42 #include <sys/stat.h>
43 #include <sys/wait.h>
44
45 #ifndef _GNU_SOURCE
46 extern char **environ; // Define environment variables
47 #endif /* _GNU_SOURCE */
48 #endif /* PLATFORM_WINDOWS */
49
50 #if defined(PLATFORM_POSIX) && defined(_GNU_SOURCE)
51 #define PLATFORM_HAS_EXECVPE
52 #endif
53
54
55 namespace lsp
56 {
57 namespace ipc
58 {
59
60 #if defined(PLATFORM_WINDOWS) || (!defined(PLATFORM_HAS_EXECVPE))
61 static status_t find_executable(LSPString & program, const LSPString & command)
62 {
63 if (command.index_of(FILE_SEPARATOR_C) >= 0)
64 return STATUS_NOT_FOUND;
65
66 // Lookup PATH
67 LSPString path;
68 status_t res = system::get_env_var("PATH", &path);
69 if (res != STATUS_OK)
70 return res;
71
72 ssize_t start = 0, count = path.length(), found = 0;
73 do
74 {
75 // Lookup for separator
76 found = path.index_of(start, ';');
77 const ssize_t next = (found >= 0) ? found : count;
78
79 if (start < next)
80 {
81 if (!program.set(&path, start, found))
82 return STATUS_NO_MEM;
83 if (!program.ends_with(FILE_SEPARATOR_C))
84 {
85 if (!program.append(FILE_SEPARATOR_C))
86 return STATUS_NO_MEM;
87 }
88 if (!program.append(&command))
89 return STATUS_NO_MEM;
90
91 #ifdef PLATFORM_WINDOWS
92 if (PathFileExistsW(program.get_utf16()))
93 return STATUS_OK;
94
95 // Try .EXE and .COM extensions
96 if ((!program.ends_with_ascii_nocase(".exe")) &&
97 (!program.ends_with_ascii_nocase(".com")))
98 {
99 // Try ".EXE"
100 if (!program.append_ascii(".exe"))
101 return STATUS_NO_MEM;
102 if (PathFileExistsW(program.get_utf16()))
103 return STATUS_OK;
104
105 // Try ".COM"
106 program.set_length(program.length() - 4);
107 if (!program.append_ascii(".com"))
108 return STATUS_NO_MEM;
109 if (PathFileExistsW(program.get_utf16()))
110 return STATUS_OK;
111 }
112 #else
113 struct stat st;
114 if (stat(program.get_native(), &st) == 0)
115 {
116 if (S_ISREG(st.st_mode) && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
117 return STATUS_OK;
118 }
119 #endif /* PLATFORM_WINDOWS */
120 }
121
122 start = found + 1;
123 } while (found >= 0);
124
125 return STATUS_NOT_FOUND;
126 }
127 #endif /* PLATFORM_HAS_EXECPE */
128
129 Process::Process()
130 {
131 nStatus = PSTATUS_CREATED;
132 nExitCode = 0;
133
134 #ifdef PLATFORM_WINDOWS
135 nPID = 0;
136 hProcess = NULL;
137 hStdIn = NULL;
138 hStdOut = NULL;
139 hStdErr = NULL;
140 #else
141 nPID = 0;
142 hStdIn = -1;
143 hStdOut = -1;
144 hStdErr = -1;
145 #endif
146
147 pStdIn = NULL;
148 pStdOut = NULL;
149 pStdErr = NULL;
150
151 if (copy_env() != STATUS_OK)
152 nStatus = PSTATUS_ERROR;
153 }
154
155 Process::~Process()
156 {
157 destroy_args(&vArgs);
158 destroy_env(&vEnv);
159 close_handles();
160
161 if (pStdIn != NULL)
162 {
163 pStdIn->close();
164 delete pStdIn;
165 pStdIn = NULL;
166 }
167
168 if (pStdOut != NULL)
169 {
170 pStdOut->close();
171 delete pStdOut;
172 pStdOut = NULL;
173 }
174
175 if (pStdErr != NULL)
176 {
177 pStdErr->close();
178 delete pStdErr;
179 pStdErr = NULL;
180 }
181
182 #ifdef PLATFORM_WINDOWS
183 if (hProcess != NULL)
184 {
185 ::CloseHandle(hProcess);
186 hProcess = NULL;
187 }
188 #endif /* PLATFORM_WINDOWS */
189 }
190
191 void Process::destroy_args(lltl::parray<LSPString> *args)
192 {
193 for (size_t i=0, n=args->size(); i<n; ++i)
194 delete args->uget(i);
195 args->flush();
196 }
197
198 void Process::destroy_env(lltl::parray<envvar_t> *env)
199 {
200 for (size_t i=0, n=env->size(); i<n; ++i)
201 delete env->uget(i);
202 env->flush();
203 }
204
205 status_t Process::set_command(const LSPString *cmd)
206 {
207 if (nStatus != PSTATUS_CREATED)
208 return STATUS_BAD_STATE;
209
210 if (cmd == NULL)
211 {
212 sCommand.clear();
213 return STATUS_OK;
214 }
215
216 return (sCommand.set(cmd)) ? STATUS_OK : STATUS_NO_MEM;
217 }
218
219 status_t Process::set_command(const char *cmd)
220 {
221 if (nStatus != PSTATUS_CREATED)
222 return STATUS_BAD_STATE;
223
224 if (cmd == NULL)
225 {
226 sCommand.clear();
227 return STATUS_OK;
228 }
229
230 return (sCommand.set_utf8(cmd)) ? STATUS_OK : STATUS_NO_MEM;
231 }
232
233 size_t Process::args() const
234 {
235 return vArgs.size();
236 }
237
238 status_t Process::add_arg(const LSPString *value)
239 {
240 if (value == NULL)
241 return STATUS_BAD_ARGUMENTS;
242 if (nStatus != PSTATUS_CREATED)
243 return STATUS_BAD_STATE;
244
245 LSPString *arg = new LSPString();
246 if (arg == NULL)
247 return STATUS_NO_MEM;
248
249 if (!arg->set(value))
250 {
251 delete arg;
252 return STATUS_NO_MEM;
253 }
254 if (!vArgs.add(arg))
255 {
256 delete arg;
257 return STATUS_NO_MEM;
258 }
259
260 return STATUS_OK;
261 }
262
263 status_t Process::add_arg(const char *value)
264 {
265 if (value == NULL)
266 return STATUS_BAD_ARGUMENTS;
267 if (nStatus != PSTATUS_CREATED)
268 return STATUS_BAD_STATE;
269
270 LSPString *arg = new LSPString();
271 if (arg == NULL)
272 return STATUS_NO_MEM;
273
274 if (!arg->set_utf8(value))
275 {
276 delete arg;
277 return STATUS_NO_MEM;
278 }
279 if (!vArgs.add(arg))
280 {
281 delete arg;
282 return STATUS_NO_MEM;
283 }
284
285 return STATUS_OK;
286 }
287
288 status_t Process::set_arg(size_t index, const LSPString *value)
289 {
290 if (value == NULL)
291 return STATUS_BAD_ARGUMENTS;
292 if (nStatus != PSTATUS_CREATED)
293 return STATUS_BAD_STATE;
294
295 LSPString *ptr = vArgs.get(index);
296 if (ptr == NULL)
297 return STATUS_BAD_ARGUMENTS;
298 return (ptr->set(value)) ? STATUS_OK : STATUS_NO_MEM;
299 }
300
301 status_t Process::set_arg(size_t index, const char *value)
302 {
303 if (value == NULL)
304 return STATUS_BAD_ARGUMENTS;
305 if (nStatus != PSTATUS_CREATED)
306 return STATUS_BAD_STATE;
307
308 LSPString *ptr = vArgs.get(index);
309 if (ptr == NULL)
310 return STATUS_BAD_ARGUMENTS;
311 return (ptr->set_utf8(value)) ? STATUS_OK : STATUS_NO_MEM;
312 }
313
314 status_t Process::get_arg(size_t index, LSPString *value)
315 {
316 LSPString *ptr = vArgs.get(index);
317 if (ptr == NULL)
318 return STATUS_BAD_ARGUMENTS;
319 if (value == NULL)
320 return STATUS_OK;
321 return (value->set(ptr)) ? STATUS_OK : STATUS_NO_MEM;
322 }
323
324 status_t Process::get_arg(size_t index, char **value)
325 {
326 LSPString *ptr = vArgs.get(index);
327 if (ptr == NULL)
328 return STATUS_BAD_ARGUMENTS;
329 if (value == NULL)
330 return STATUS_OK;
331
332 char *dup = ptr->clone_utf8();
333 if (dup == NULL)
334 return STATUS_NO_MEM;
335
336 *value = dup;
337 return STATUS_OK;
338 }
339
340 status_t Process::remove_arg(size_t index, LSPString *value)
341 {
342 if (nStatus != PSTATUS_CREATED)
343 return STATUS_BAD_STATE;
344
345 LSPString *ptr = vArgs.get(index);
346 if (ptr == NULL)
347 return STATUS_BAD_ARGUMENTS;
348 if (value != NULL)
349 value->swap(ptr);
350
351 vArgs.remove(index);
352 delete ptr;
353 return STATUS_OK;
354 }
355
356 status_t Process::remove_arg(size_t index, char **value)
357 {
358 if (nStatus != PSTATUS_CREATED)
359 return STATUS_BAD_STATE;
360
361 LSPString *ptr = vArgs.get(index);
362 if (ptr == NULL)
363 return STATUS_BAD_ARGUMENTS;
364 if (value != NULL)
365 {
366 char *dup = ptr->clone_utf8();
367 if (dup == NULL)
368 return STATUS_NO_MEM;
369
370 *value = dup;
371 }
372
373 vArgs.remove(index);
374 delete ptr;
375 return STATUS_OK;
376 }
377
378 status_t Process::insert_arg(size_t index, const LSPString *value)
379 {
380 if (nStatus != PSTATUS_CREATED)
381 return STATUS_BAD_STATE;
382 if (value == NULL)
383 return STATUS_BAD_ARGUMENTS;
384
385 LSPString *arg = new LSPString();
386 if (arg == NULL)
387 return STATUS_NO_MEM;
388
389 if ((!arg->set(value)) || (!vArgs.insert(index, arg)))
390 {
391 delete arg;
392 return STATUS_NO_MEM;
393 }
394
395 return STATUS_OK;
396 }
397
398 status_t Process::insert_arg(size_t index, const char *value)
399 {
400 if (nStatus != PSTATUS_CREATED)
401 return STATUS_BAD_STATE;
402 if (value == NULL)
403 return STATUS_BAD_ARGUMENTS;
404
405 LSPString *arg = new LSPString();
406 if (arg == NULL)
407 return STATUS_NO_MEM;
408
409 if ((!arg->set_utf8(value)) || (!vArgs.insert(index, arg)))
410 {
411 delete arg;
412 return STATUS_NO_MEM;
413 }
414
415 return STATUS_OK;
416 }
417
418 status_t Process::clear_args()
419 {
420 if (nStatus != PSTATUS_CREATED)
421 return STATUS_BAD_STATE;
422 destroy_args(&vArgs);
423 return STATUS_OK;
424 }
425
426 size_t Process::envs() const
427 {
428 return vEnv.size();
429 }
430
431 status_t Process::set_env(const LSPString *key, const LSPString *value)
432 {
433 if (nStatus != PSTATUS_CREATED)
434 return STATUS_BAD_STATE;
435 if ((key == NULL) || (value == NULL))
436 return STATUS_BAD_ARGUMENTS;
437 if (key->index_of('=') >= 0)
438 return STATUS_BAD_FORMAT;
439
440 envvar_t *var;
441 for (size_t i=0, n=vEnv.size(); i<n; ++i)
442 {
443 var = vEnv.uget(i);
444 if (var->name.equals(key))
445 return (var->value.set(value)) ? STATUS_OK : STATUS_NO_MEM;
446 }
447
448 if ((var = new envvar_t) == NULL)
449 return STATUS_NO_MEM;
450
451 if ((!var->name.set(key)) || (!var->value.set(value)) || (!vEnv.add(var)))
452 {
453 delete var;
454 return STATUS_NO_MEM;
455 }
456
457 return STATUS_OK;
458 }
459
460 status_t Process::set_env(const char *key, const char *value)
461 {
462 if (nStatus != PSTATUS_CREATED)
463 return STATUS_BAD_STATE;
464 if ((key == NULL) || (value == NULL))
465 return STATUS_BAD_ARGUMENTS;
466 if (strchr(key, '=') != NULL)
467 return STATUS_BAD_FORMAT;
468
469 LSPString k, v;
470 if ((!k.set_utf8(key)) || (!v.set_utf8(value)))
471 return STATUS_NO_MEM;
472 return set_env(&k, &v);
473 }
474
475 status_t Process::remove_env(const LSPString *key, LSPString *value)
476 {
477 if (nStatus != PSTATUS_CREATED)
478 return STATUS_BAD_STATE;
479 if (key == NULL)
480 return STATUS_BAD_ARGUMENTS;
481
482 for (size_t i=0, n=vEnv.size(); i<n; ++i)
483 {
484 envvar_t *var = vEnv.uget(i);
485 if (var->name.equals(key))
486 {
487 if (value != NULL)
488 value->swap(&var->value);
489 delete var;
490 vEnv.qremove(i);
491 return STATUS_OK;
492 }
493 }
494
495 return STATUS_NOT_FOUND;
496 }
497
498 status_t Process::remove_env(const char *key, char **value)
499 {
500 if (nStatus != PSTATUS_CREATED)
501 return STATUS_BAD_STATE;
502 if (key == NULL)
503 return STATUS_BAD_ARGUMENTS;
504
505 LSPString k;
506 if (!k.set_utf8(key))
507 return STATUS_NO_MEM;
508
509 for (size_t i=0, n=vEnv.size(); i<n; ++i)
510 {
511 envvar_t *var = vEnv.uget(i);
512 if (var->name.equals(&k))
513 {
514 if (value != NULL)
515 {
516 char *dup = var->value.clone_utf8();
517 if (dup == NULL)
518 return STATUS_NO_MEM;
519 *value = dup;
520 }
521 delete var;
522 vEnv.qremove(i);
523 return STATUS_OK;
524 }
525 }
526
527 return STATUS_NOT_FOUND;
528 }
529
530 status_t Process::remove_env(const char *key, LSPString *value)
531 {
532 if (nStatus != PSTATUS_CREATED)
533 return STATUS_BAD_STATE;
534 if (key == NULL)
535 return STATUS_BAD_ARGUMENTS;
536
537 LSPString k;
538 if (!k.set_utf8(key))
539 return STATUS_NO_MEM;
540
541 for (size_t i=0, n=vEnv.size(); i<n; ++i)
542 {
543 envvar_t *var = vEnv.uget(i);
544 if (!var->name.equals(&k))
545 continue;
546
547 if (value != NULL)
548 value->swap(&var->value);
549 delete var;
550 vEnv.qremove(i);
551 return STATUS_OK;
552 }
553
554 return STATUS_NOT_FOUND;
555 }
556
557 status_t Process::get_env(const LSPString *key, LSPString *value)
558 {
559 if (key == NULL)
560 return STATUS_BAD_ARGUMENTS;
561
562 if (nStatus != PSTATUS_CREATED)
563 return STATUS_BAD_STATE;
564
565 for (size_t i=0, n=vEnv.size(); i<n; ++i)
566 {
567 envvar_t *var = vEnv.uget(i);
568 if (!var->name.equals(key))
569 continue;
570
571 if (value != NULL)
572 {
573 if (!value->set(&var->value))
574 return STATUS_NO_MEM;
575 }
576 return STATUS_OK;
577 }
578
579 return STATUS_NOT_FOUND;
580 }
581
582 status_t Process::get_env(const char *key, LSPString *value)
583 {
584 if (key == NULL)
585 return STATUS_BAD_ARGUMENTS;
586
587 LSPString k;
588 if (!k.set_utf8(key))
589 return STATUS_NO_MEM;
590
591 for (size_t i=0, n=vEnv.size(); i<n; ++i)
592 {
593 envvar_t *var = vEnv.uget(i);
594 if (!var->name.equals(&k))
595 continue;
596
597 if (value != NULL)
598 {
599 if (!value->set(&var->value))
600 return STATUS_NO_MEM;
601 }
602 return STATUS_OK;
603 }
604
605 return STATUS_NOT_FOUND;
606 }
607
608 status_t Process::get_env(const char *key, char **value)
609 {
610 if (key == NULL)
611 return STATUS_BAD_ARGUMENTS;
612
613 LSPString k;
614 if (!k.set_utf8(key))
615 return STATUS_NO_MEM;
616
617 for (size_t i=0, n=vEnv.size(); i<n; ++i)
618 {
619 envvar_t *var = vEnv.uget(i);
620 if (!var->name.equals(&k))
621 continue;
622
623 if (value != NULL)
624 {
625 char *dup = var->value.clone_utf8();
626 if (dup == NULL)
627 return STATUS_NO_MEM;
628 *value = dup;
629 }
630 return STATUS_OK;
631 }
632
633 return STATUS_NOT_FOUND;
634 }
635
636 status_t Process::read_env(size_t idx, LSPString *key, LSPString *value)
637 {
638 if ((key == NULL) && (value == NULL))
639 return STATUS_BAD_ARGUMENTS;
640
641 envvar_t *var = vEnv.get(idx);
642 if (var == NULL)
643 return STATUS_BAD_ARGUMENTS;
644
645 LSPString tk, tv;
646 if (key != NULL)
647 {
648 if (!tk.set(&var->name))
649 return STATUS_NO_MEM;
650 if (value != NULL)
651 {
652 if (!tv.set(&var->value))
653 return STATUS_NO_MEM;
654 value->swap(&tv);
655 }
656
657 key->swap(&tk);
658 return STATUS_OK;
659 }
660
661 if (!tv.set(&var->value))
662 return STATUS_NO_MEM;
663
664 value->swap(&tv);
665 return STATUS_OK;
666 }
667
668 status_t Process::read_env(size_t idx, char **key, char **value)
669 {
670 if ((key == NULL) && (value == NULL))
671 return STATUS_BAD_ARGUMENTS;
672
673 envvar_t *var = vEnv.get(idx);
674 if (var == NULL)
675 return STATUS_BAD_ARGUMENTS;
676
677 char *tk, *tv;
678
679 if (key != NULL)
680 {
681 if ((tk = var->name.clone_utf8()) == NULL)
682 return STATUS_NO_MEM;
683
684 if (value != NULL)
685 {
686 if ((tv = var->value.clone_utf8()) == NULL)
687 {
688 ::free(tk);
689 return STATUS_NO_MEM;
690 }
691
692 *value = tv;
693 }
694
695 *key = tk;
696 return STATUS_OK;
697 }
698
699 if ((tv = var->value.clone_utf8()) == NULL)
700 return STATUS_NO_MEM;
701
702 *value = tv;
703 return STATUS_OK;
704 }
705
706 status_t Process::clear_env()
707 {
708 if (nStatus != PSTATUS_CREATED)
709 return STATUS_BAD_STATE;
710 destroy_env(&vEnv);
711 return STATUS_OK;
712 }
713
714 size_t Process::status()
715 {
716 wait(0); // Try to update status
717 return nStatus;
718 }
719
720 bool Process::exited()
721 {
722 return status() == PSTATUS_EXITED;
723 }
724
725 bool Process::running()
726 {
727 if (nStatus == PSTATUS_RUNNING_ERROR)
728 return true;
729 return status() == PSTATUS_RUNNING;
730 }
731
732 bool Process::valid()
733 {
734 return status() != PSTATUS_ERROR;
735 }
736
737 ssize_t Process::process_id() const
738 {
739 switch (nStatus)
740 {
741 case PSTATUS_RUNNING:
742 case PSTATUS_EXITED:
743 return nPID;
744 default:
745 break;
746 }
747 return -1;
748 }
749
750 status_t Process::exit_code(int *code)
751 {
752 if (code == NULL)
753 return STATUS_BAD_ARGUMENTS;
754
755 if (nStatus != PSTATUS_EXITED)
756 return STATUS_BAD_STATE;
757
758 *code = nExitCode;
759 return STATUS_OK;
760 }
761
762 #ifdef PLATFORM_WINDOWS
763 status_t Process::append_arg_escaped(LSPString *dst, const LSPString *value)
764 {
765 if (value->is_empty())
766 return (dst->append_ascii("\"\"")) ? STATUS_OK : STATUS_NO_MEM;
767
768 for (size_t i=0, n=value->length(); i<n; ++i)
769 {
770 lsp_wchar_t ch = value->char_at(i);
771 switch (ch)
772 {
773 case ' ':
774 if (!dst->append_ascii("\" \"", 3))
775 return STATUS_NO_MEM;
776 break;
777 case '"':
778 if (!dst->append_ascii("\\\"", 2))
779 return STATUS_NO_MEM;
780 break;
781 default:
782 if (!dst->append(ch))
783 return STATUS_NO_MEM;
784 break;
785 }
786 }
787
788 return STATUS_OK;
789 }
790
791 status_t Process::build_argv(LSPString *dst)
792 {
793 status_t res = append_arg_escaped(dst, &sCommand);
794 if (res != STATUS_OK)
795 return res;
796
797 for (size_t i=0, n=vArgs.size(); i<n; ++i)
798 {
799 LSPString *arg = vArgs.uget(i);
800 if (!dst->append(' '))
801 return STATUS_NO_MEM;
802 res = append_arg_escaped(dst, arg);
803 if (res != STATUS_OK)
804 return res;
805 }
806
807 return STATUS_OK;
808 }
809
810 status_t Process::build_envp(LSPString *dst)
811 {
812 for (size_t i=0, n=vEnv.size(); i<n; ++i)
813 {
814 envvar_t *env = vEnv.uget(i);
815 if (!dst->append(&env->name))
816 return STATUS_NO_MEM;
817 if (!dst->append('='))
818 return STATUS_NO_MEM;
819 if (!dst->append(&env->value))
820 return STATUS_NO_MEM;
821 if (!dst->append('\0'))
822 return STATUS_NO_MEM;
823 }
824
825 // Note that an ANSI environment block is terminated by two zero bytes:
826 // one for the last string, one more to terminate the block. A Unicode
827 // environment block is terminated by four zero bytes: two for the last
828 // string, two more to terminate the block.
829 return (dst->append('\0')) ? STATUS_OK : STATUS_NO_MEM;
830 }
831
832 status_t Process::launch()
833 {
834 if (nStatus != PSTATUS_CREATED)
835 return STATUS_BAD_STATE;
836 if (sCommand.is_empty())
837 return STATUS_BAD_STATE;
838
839 // Obtain the command string
840 status_t res;
841 LSPString xcmd;
842 res = find_executable(xcmd, sCommand);
843 if ((res != STATUS_OK) && (res != STATUS_NOT_FOUND))
844 return res;
845 LSPString & program = (res == STATUS_OK) ? xcmd : sCommand;
846
847 // Form argv and envp
848 LSPString argv, envp;
849 if ((res = build_argv(&argv)) != STATUS_OK)
850 return res;
851 if ((res = build_envp(&envp)) != STATUS_OK)
852 return res;
853
854 // Launch child process
855 STARTUPINFOW si;
856 PROCESS_INFORMATION pi;
857
858 ZeroMemory( &si, sizeof(STARTUPINFOW) );
859 ZeroMemory( &pi, sizeof(PROCESS_INFORMATION) );
860 si.cb = sizeof(si);
861
862 // Override STDIN, STDOUT, STDERR
863 if (hStdIn != NULL)
864 {
865 si.dwFlags |= STARTF_USESTDHANDLES;
866 si.hStdInput = hStdIn;
867 }
868 if (hStdOut != NULL)
869 {
870 si.dwFlags |= STARTF_USESTDHANDLES;
871 si.hStdOutput = hStdOut;
872 }
873 if (hStdErr != NULL)
874 {
875 si.dwFlags |= STARTF_USESTDHANDLES;
876 si.hStdError = hStdErr;
877 }
878
879 // Prepare buffers
880 WCHAR *wargv = argv.clone_utf16();
881 if (wargv == NULL)
882 return STATUS_NO_MEM;
883
884 WCHAR *wenvp = envp.clone_utf16();
885 if (wenvp == NULL)
886 {
887 ::free(wargv);
888 return STATUS_NO_MEM;
889 }
890
891 // Start the child process.
892 if( !::CreateProcessW(
893 program.get_utf16(), // Module name (use command line)
894 wargv, // Command line
895 NULL, // Process handle not inheritable
896 NULL, // Thread handle not inheritable
897 FALSE, // Set handle inheritance to FALSE
898 CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT, // Use unicode environment
899 wenvp, // Set-up environment block
900 NULL, // Use parent's starting directory
901 &si, // Pointer to STARTUPINFO structure
902 &pi // Pointer to PROCESS_INFORMATION structure
903 ))
904 {
905 int error = ::GetLastError();
906 ::fprintf(stderr, "Failed to create child process (%d)\n", error);
907 ::fflush(stderr);
908
909 ::free(wenvp);
910 ::free(wargv);
911
912 nStatus = PSTATUS_RUNNING_ERROR;
913 switch (error)
914 {
915 case ERROR_FILE_NOT_FOUND:
916 case ERROR_PATH_NOT_FOUND:
917 nExitCode = STATUS_NOT_FOUND;
918 break;
919 default:
920 nExitCode = STATUS_UNKNOWN_ERR;
921 break;
922 }
923
924 return res;
925 }
926
927 // Free resources and close redirected file handles
928 ::free(wenvp);
929 ::free(wargv);
930 close_handles();
931
932 // Update state
933 hProcess = pi.hProcess;
934 nPID = pi.dwProcessId;
935 nStatus = PSTATUS_RUNNING;
936
937 return res;
938 }
939
940 status_t Process::wait(wssize_t millis)
941 {
942 // If we're simulating some process that failed to start as running,
943 // then we need to update the status and just return.
944 // Otherwise we need to reject any wait() request since process is in
945 // bad state.
946 if (nStatus == PSTATUS_RUNNING_ERROR)
947 {
948 nStatus = PSTATUS_EXITED;
949 return STATUS_OK;
950 }
951 else if (nStatus != PSTATUS_RUNNING)
952 return STATUS_BAD_STATE;
953
954 // Wait for completion of the process
955 DWORD res = ::WaitForSingleObject(hProcess, (millis < 0) ? INFINITE : millis);
956 switch (res)
957 {
958 case WAIT_OBJECT_0:
959 {
960 // Obtain exit status of process
961 DWORD code = 0;
962 ::GetExitCodeProcess(hProcess, &code);
963 ::CloseHandle(hProcess);
964 hProcess = NULL;
965
966 // Update state
967 nStatus = PSTATUS_EXITED;
968 nExitCode = code;
969 return STATUS_OK;
970 }
971
972 case WAIT_TIMEOUT:
973 return STATUS_OK;
974
975 default:
976 break;
977 }
978
979 return STATUS_UNKNOWN_ERR;
980 }
981
982 void Process::close_handles()
983 {
984 if (hStdIn != NULL)
985 {
986 ::CloseHandle(hStdIn);
987 hStdIn = NULL;
988 }
989 if (hStdOut != NULL)
990 {
991 ::CloseHandle(hStdOut);
992 hStdOut = NULL;
993 }
994 if (hStdErr != NULL)
995 {
996 ::CloseHandle(hStdErr);
997 hStdErr = NULL;
998 }
999 }
1000
1001 io::IOutStream *Process::get_stdin()
1002 {
1003 if ((nStatus != PSTATUS_CREATED) || (pStdIn != NULL))
1004 return pStdIn;
1005
1006 HANDLE hRead = NULL, hWrite = NULL;
1007 if (!::CreatePipe(&hRead, &hWrite, NULL, 0))
1008 return NULL;
1009
1010 // Create stream and wrap
1011 io::OutFileStream *strm = new io::OutFileStream();
1012 if ((strm == NULL) || (strm->wrap_native(hWrite, true) != STATUS_OK))
1013 {
1014 delete strm;
1015 ::CloseHandle(hRead);
1016 ::CloseHandle(hWrite);
1017 return NULL;
1018 }
1019
1020 // All is OK
1021 pStdIn = strm;
1022 hStdIn = hRead;
1023
1024 return pStdIn;
1025 }
1026
1027 io::IInStream *Process::get_stdout()
1028 {
1029 if ((nStatus != PSTATUS_CREATED) || (pStdOut != NULL))
1030 return pStdOut;
1031
1032 HANDLE hRead = NULL, hWrite = NULL;
1033 if (!::CreatePipe(&hRead, &hWrite, NULL, 0))
1034 return NULL;
1035
1036 // Create stream and wrap
1037 io::InFileStream *strm = new io::InFileStream();
1038 if ((strm == NULL) || (strm->wrap_native(hRead, true) != STATUS_OK))
1039 {
1040 delete strm;
1041 ::CloseHandle(hRead);
1042 ::CloseHandle(hWrite);
1043 return NULL;
1044 }
1045
1046 // All is OK
1047 pStdOut = strm;
1048 hStdOut = hWrite;
1049
1050 return pStdOut;
1051 }
1052
1053 io::IInStream *Process::get_stderr()
1054 {
1055 if ((nStatus != PSTATUS_CREATED) || (pStdErr != NULL))
1056 return pStdErr;
1057
1058 HANDLE hRead = NULL, hWrite = NULL;
1059 if (!::CreatePipe(&hRead, &hWrite, NULL, 0))
1060 return NULL;
1061
1062 // Create stream and wrap
1063 io::InFileStream *strm = new io::InFileStream();
1064 if ((strm == NULL) || (strm->wrap_native(hRead, true) != STATUS_OK))
1065 {
1066 delete strm;
1067 ::CloseHandle(hRead);
1068 ::CloseHandle(hWrite);
1069 return NULL;
1070 }
1071
1072 // All is OK
1073 pStdErr = strm;
1074 hStdErr = hWrite;
1075
1076 return pStdErr;
1077 }
1078 #else
1079 static void drop_data(lltl::parray<char> *v)
1080 {
1081 for (size_t i=0, n=v->size(); i<n; ++i)
1082 {
1083 char *ptr = v->uget(i);
1084 if (ptr != NULL)
1085 ::free(ptr);
1086 }
1087 v->flush();
1088 }
1089
1090 void Process::close_handles()
1091 {
1092 if (hStdIn >= 0)
1093 {
1094 ::close(hStdIn);
1095 hStdIn = -1;
1096 }
1097 if (hStdOut >= 0)
1098 {
1099 ::close(hStdOut);
1100 hStdOut = -1;
1101 }
1102 if (hStdErr >= 0)
1103 {
1104 ::close(hStdErr);
1105 hStdErr = -1;
1106 }
1107 }
1108
1109 status_t Process::build_argv(lltl::parray<char> *dst)
1110 {
1111 char *s;
1112
1113 // Add command as argv[0]
1114 if ((s = sCommand.clone_native()) == NULL)
1115 return STATUS_NO_MEM;
1116 if (!dst->add(s))
1117 return STATUS_NO_MEM;
1118
1119 // Add all other arguments
1120 for (size_t i=0, n=vArgs.size(); i<n; ++i)
1121 {
1122 LSPString *arg = vArgs.uget(i);
1123 if (arg == NULL)
1124 continue;
1125
1126 if ((s = arg->clone_native()) == NULL)
1127 return STATUS_NO_MEM;
1128 if (!dst->add(s))
1129 {
1130 ::free(s);
1131 return STATUS_NO_MEM;
1132 }
1133 }
1134
1135 // Add terminator
1136 return (dst->add(static_cast<char *>(NULL))) ? STATUS_OK : STATUS_NO_MEM;
1137 }
1138
1139 status_t Process::build_envp(lltl::parray<char> *dst)
1140 {
1141 char *s;
1142
1143 LSPString tmp;
1144 for (size_t i=0, n=vEnv.size(); i<n; ++i)
1145 {
1146 envvar_t *var = vEnv.uget(i);
1147 if (var == NULL)
1148 continue;
1149 if (!tmp.set(&var->name))
1150 return STATUS_NO_MEM;
1151 if (!tmp.append('='))
1152 return STATUS_NO_MEM;
1153 if (!tmp.append(&var->value))
1154 return STATUS_NO_MEM;
1155
1156 if ((s = tmp.clone_native()) == NULL)
1157 return STATUS_NO_MEM;
1158
1159 if (!dst->add(s))
1160 {
1161 ::free(s);
1162 return STATUS_NO_MEM;
1163 }
1164 }
1165 return (dst->add(static_cast<char *>(NULL))) ? STATUS_OK : STATUS_NO_MEM;
1166 }
1167
1168 status_t Process::spawn_process(const char *cmd, char * const *argv, char * const *envp)
1169 {
1170 lsp_trace("Creating child process using posix_spawn...");
1171
1172 // Initialize spawn routines
1173 posix_spawnattr_t attr;
1174 if (::posix_spawnattr_init(&attr))
1175 return STATUS_UNKNOWN_ERR;
1176
1177 #if defined(__USE_GNU) || defined(POSIX_SPAWN_USEVFORK)
1178 // Prever vfork() over fork()
1179 if (::posix_spawnattr_setflags(&attr, POSIX_SPAWN_USEVFORK))
1180 {
1181 ::posix_spawnattr_destroy(&attr);
1182 return STATUS_UNKNOWN_ERR;
1183 }
1184 #endif /* __USE_GNU */
1185
1186 posix_spawn_file_actions_t actions;
1187 if (::posix_spawn_file_actions_init(&actions))
1188 {
1189 ::posix_spawnattr_destroy(&attr);
1190 return STATUS_UNKNOWN_ERR;
1191 }
1192
1193 // Override STDIN, STDOUT, STDERR
1194 if (hStdIn >= 0)
1195 {
1196 if (::posix_spawn_file_actions_adddup2(&actions, hStdIn, STDIN_FILENO))
1197 {
1198 ::posix_spawnattr_destroy(&attr);
1199 return STATUS_UNKNOWN_ERR;
1200 }
1201 if (::posix_spawn_file_actions_addclose(&actions, hStdIn))
1202 {
1203 ::posix_spawnattr_destroy(&attr);
1204 return STATUS_UNKNOWN_ERR;
1205 }
1206 }
1207
1208 if (hStdOut >= 0)
1209 {
1210 if (::posix_spawn_file_actions_adddup2(&actions, hStdOut, STDOUT_FILENO))
1211 {
1212 ::posix_spawnattr_destroy(&attr);
1213 return STATUS_UNKNOWN_ERR;
1214 }
1215 if (::posix_spawn_file_actions_addclose(&actions, hStdOut))
1216 {
1217 ::posix_spawnattr_destroy(&attr);
1218 return STATUS_UNKNOWN_ERR;
1219 }
1220 }
1221
1222 if (hStdErr >= 0)
1223 {
1224 if (::posix_spawn_file_actions_adddup2(&actions, hStdErr, STDERR_FILENO))
1225 {
1226 ::posix_spawnattr_destroy(&attr);
1227 return STATUS_UNKNOWN_ERR;
1228 }
1229 if (::posix_spawn_file_actions_addclose(&actions, hStdErr))
1230 {
1231 ::posix_spawnattr_destroy(&attr);
1232 return STATUS_UNKNOWN_ERR;
1233 }
1234 }
1235
1236 // Perform posix_spawn()
1237 pid_t pid;
1238 status_t res = STATUS_OK;
1239 while (true)
1240 {
1241 int x = ::posix_spawnp(&pid, cmd, &actions, &attr, argv, envp);
1242 switch (x)
1243 {
1244 case 0: break;
1245 case EAGAIN: continue;
1246 case ENOMEM: res = STATUS_NO_MEM; break;
1247 default: res = STATUS_UNKNOWN_ERR; break;
1248 }
1249 break;
1250 }
1251
1252 // Success execution?
1253 if (res == STATUS_OK)
1254 {
1255 nPID = pid;
1256 nStatus = PSTATUS_RUNNING;
1257 }
1258
1259 ::posix_spawn_file_actions_destroy(&actions);
1260 ::posix_spawnattr_destroy(&attr);
1261
1262 return res;
1263 }
1264
1265 void Process::execvpe_process(const char *cmd, char * const *argv, char * const *envp, bool soft_exit)
1266 {
1267 // Override STDIN, STDOUT, STDERR
1268 if (hStdIn >= 0)
1269 {
1270 ::dup2(hStdIn, STDIN_FILENO);
1271 ::close(hStdIn);
1272 hStdIn = -1;
1273 }
1274
1275 if (hStdOut >= 0)
1276 {
1277 ::dup2(hStdOut, STDOUT_FILENO);
1278 ::close(hStdOut);
1279 hStdOut = -1;
1280 }
1281
1282 if (hStdErr >= 0)
1283 {
1284 ::dup2(hStdErr, STDERR_FILENO);
1285 ::close(hStdErr);
1286 hStdErr = -1;
1287 }
1288
1289 // Launch the process
1290 #ifndef PLATFORM_HAS_EXECVPE
1291 ::execve(cmd, argv, envp);
1292 #else
1293 if (strchr(cmd, FILE_SEPARATOR_C) != NULL)
1294 ::execve(cmd, argv, envp);
1295 else
1296 ::execvpe(cmd, argv, envp);
1297 #endif /* PLATFORM_HAS_EXECVPE */
1298
1299 lsp_trace("exec failed for pid=%d\n", int(getpid()));
1300
1301 // Return error only if ::execvpe failed
1302 if (soft_exit)
1303 ::_exit(STATUS_UNKNOWN_ERR);
1304 else
1305 ::exit(STATUS_UNKNOWN_ERR);
1306 }
1307
1308 status_t Process::vfork_process(const char *cmd, char * const *argv, char * const *envp)
1309 {
1310 lsp_trace("Creating child process using vfork()...");
1311 errno = 0;
1312
1313 #ifdef PLATFORM_MACOSX
1314 #if defined(COMPILER_CLANG)
1315 #pragma clang diagnostic push
1316 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
1317 #elif defined(COMPILER_GCC)
1318 #pragma GCC diagnostic push
1319 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1320 #endif
1321 #endif /* PLATFORM_MACOSX */
1322
1323 // vfork() is deprecated in MacOS, we'll hide deprectation warning for that as
1324 // vfork() is a fallback case for posix_spawn.
1325 pid_t pid = ::vfork();
1326
1327 #ifdef PLATFORM_MACOSX
1328 #if defined(COMPILER_CLANG)
1329 #pragma clang diagnostic pop
1330 #elif defined(COMPILER_GCC)
1331 #pragma GCC diagnostic pop
1332 #endif
1333 #endif /* PLATFORM_MACOSX */
1334
1335 // Failed to fork()?
1336 if (pid < 0)
1337 {
1338 int code = errno;
1339 switch (code)
1340 {
1341 case ENOMEM: return STATUS_NO_MEM;
1342 case EAGAIN: return STATUS_NO_MEM;
1343 default: return STATUS_UNKNOWN_ERR;
1344 }
1345 }
1346
1347 // The child process stuff
1348 if (pid == 0)
1349 execvpe_process(cmd, argv, envp, true);
1350
1351 // The parent process stuff
1352 nPID = pid;
1353 nStatus = PSTATUS_RUNNING;
1354
1355 return STATUS_OK;
1356 }
1357
1358 status_t Process::fork_process(const char *cmd, char * const *argv, char * const *envp)
1359 {
1360 lsp_trace("Creating child process using fork()...");
1361 errno = 0;
1362 pid_t pid = ::fork();
1363
1364 // Failed to fork()?
1365 if (pid < 0)
1366 {
1367 int code = errno;
1368 switch (code)
1369 {
1370 case ENOMEM: return STATUS_NO_MEM;
1371 case EAGAIN: return STATUS_NO_MEM;
1372 default: return STATUS_UNKNOWN_ERR;
1373 }
1374 }
1375
1376 // The child process stuff
1377 if (pid == 0)
1378 execvpe_process(cmd, argv, envp, false);
1379
1380 // The parent process stuff
1381 nPID = pid;
1382 nStatus = PSTATUS_RUNNING;
1383
1384 return STATUS_OK;
1385 }
1386
1387 status_t Process::launch()
1388 {
1389 if (nStatus != PSTATUS_CREATED)
1390 return STATUS_BAD_STATE;
1391 if (sCommand.is_empty())
1392 return STATUS_BAD_STATE;
1393
1394 status_t res;
1395 lltl::parray<char> argv;
1396 lltl::parray<char> envp;
1397 lsp_finally {
1398 drop_data(&argv);
1399 drop_data(&envp);
1400 };
1401
1402 // Make execution command
1403 #ifndef PLATFORM_HAS_EXECVPE
1404 LSPString xcmd;
1405 res = find_executable(xcmd, sCommand);
1406 if ((res != STATUS_OK) && (res != STATUS_NOT_FOUND))
1407 return res;
1408
1409 char *cmd = (res == STATUS_OK) ? xcmd.clone_native() : sCommand.clone_native();
1410 #else
1411 char *cmd = sCommand.clone_native();
1412 #endif /* PLATFORM_HAS_EXECVPE */
1413 if (cmd == NULL)
1414 return STATUS_NO_MEM;
1415 lsp_finally { free(cmd); };
1416
1417 // Form argv
1418 if ((res = build_argv(&argv)) != STATUS_OK)
1419 return res;
1420
1421 // Form envp
1422 res = build_envp(&envp);
1423 if (res == STATUS_OK)
1424 {
1425 res = STATUS_UNKNOWN_ERR;
1426
1427 // Different behaviour, depending on POSIX_SPAWN_USEVFORK presence
1428 #if defined(__USE_GNU) || defined(POSIX_SPAWN_USEVFORK)
1429 res = spawn_process(cmd, argv.array(), envp.array());
1430 if (res != STATUS_OK)
1431 res = vfork_process(cmd, argv.array(), envp.array());
1432 #else
1433 res = vfork_process(cmd, argv.array(), envp.array());
1434 if (res != STATUS_OK)
1435 res = spawn_process(cmd, argv.array(), envp.array());
1436 #endif /* __USE_GNU */
1437
1438 if (res != STATUS_OK)
1439 res = fork_process(cmd, argv.array(), envp.array());
1440 }
1441
1442 // Close redirected file handles
1443 if (res == STATUS_OK)
1444 close_handles();
1445
1446 return res;
1447 }
1448
1449 status_t Process::wait(wssize_t millis)
1450 {
1451 if (nStatus != PSTATUS_RUNNING)
1452 return STATUS_BAD_STATE;
1453
1454 int status;
1455
1456 if (millis < 0)
1457 {
1458 do
1459 {
1460 // Wait for child process
1461 pid_t pid = ::waitpid(nPID, &status, WUNTRACED | WCONTINUED);
1462 if (pid < 0)
1463 {
1464 status = errno;
1465 if (status == EINTR)
1466 continue;
1467 return STATUS_UNKNOWN_ERR;
1468 }
1469 } while ((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
1470
1471 nStatus = PSTATUS_EXITED;
1472 nExitCode = WEXITSTATUS(status);
1473 }
1474 else if (millis == 0)
1475 {
1476 // Wait for child process
1477 pid_t pid = ::waitpid(nPID, &status, WUNTRACED | WCONTINUED | WNOHANG);
1478 if (pid < 0)
1479 {
1480 status = errno;
1481 return (status == EINTR) ? STATUS_OK : STATUS_UNKNOWN_ERR;
1482 }
1483
1484 // Child has exited?
1485 if ((pid == nPID) && ((WIFEXITED(status)) || (WIFSIGNALED(status))))
1486 {
1487 nStatus = PSTATUS_EXITED;
1488 nExitCode = WEXITSTATUS(status);
1489 }
1490 }
1491 else
1492 {
1493 struct timespec ts;
1494 wssize_t deadline, left;
1495 ::clock_gettime(CLOCK_REALTIME, &ts);
1496 deadline = millis + (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
1497
1498 while (true)
1499 {
1500 // Wait for child process
1501 pid_t pid = ::waitpid(nPID, &status, WUNTRACED | WCONTINUED | WNOHANG);
1502 if (pid < 0)
1503 {
1504 status = errno;
1505 if (status == EINTR)
1506 continue;
1507 return STATUS_UNKNOWN_ERR;
1508 }
1509
1510 // Child process has exited?
1511 if ((pid == nPID) && ((WIFEXITED(status)) || (WIFSIGNALED(status))))
1512 break;
1513
1514 // Get time
1515 ::clock_gettime(CLOCK_REALTIME, &ts);
1516 left = deadline - (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
1517 if (left <= 0)
1518 return STATUS_OK; // Just leave, no changes
1519
1520 // Perform short sleep
1521 ts.tv_sec = 0;
1522 ts.tv_nsec = ((left > 50) ? 50 : left) * 1000000;
1523 ::nanosleep(&ts, NULL);
1524 }
1525
1526 nStatus = PSTATUS_EXITED;
1527 nExitCode = WEXITSTATUS(status);
1528 }
1529
1530 return STATUS_OK;
1531 }
1532
1533 io::IOutStream *Process::get_stdin()
1534 {
1535 if ((nStatus != PSTATUS_CREATED) || (pStdIn != NULL))
1536 return pStdIn;
1537
1538 int fd[2]; // rw
1539 if (::pipe(fd) != 0)
1540 return NULL;
1541
1542 // Create stream and wrap
1543 io::OutFileStream *strm = new io::OutFileStream();
1544 if ((strm == NULL) || (strm->wrap_native(fd[1], true) != STATUS_OK))
1545 {
1546 delete strm;
1547 ::close(fd[0]);
1548 ::close(fd[1]);
1549 return NULL;
1550 }
1551
1552 // All is OK
1553 pStdIn = strm;
1554 hStdIn = fd[0];
1555
1556 return pStdIn;
1557 }
1558
1559 io::IInStream *Process::get_stdout()
1560 {
1561 if ((nStatus != PSTATUS_CREATED) || (pStdOut != NULL))
1562 return pStdOut;
1563
1564 int fd[2]; // rw
1565 if (::pipe(fd) != 0)
1566 return NULL;
1567
1568 // Create stream and wrap
1569 io::InFileStream *strm = new io::InFileStream();
1570 if ((strm == NULL) || (strm->wrap_native(fd[0], true) != STATUS_OK))
1571 {
1572 delete strm;
1573 ::close(fd[0]);
1574 ::close(fd[1]);
1575 return NULL;
1576 }
1577
1578 // All is OK
1579 pStdOut = strm;
1580 hStdOut = fd[1];
1581
1582 return pStdOut;
1583 }
1584
1585 io::IInStream *Process::get_stderr()
1586 {
1587 if ((nStatus != PSTATUS_CREATED) || (pStdErr != NULL))
1588 return pStdErr;
1589
1590 int fd[2]; // rw
1591 if (::pipe(fd) != 0)
1592 return NULL;
1593
1594 // Create stream and wrap
1595 io::InFileStream *strm = new io::InFileStream();
1596 if ((strm == NULL) || (strm->wrap_native(fd[0], true) != STATUS_OK))
1597 {
1598 delete strm;
1599 ::close(fd[0]);
1600 ::close(fd[1]);
1601 return NULL;
1602 }
1603
1604 // All is OK
1605 pStdErr = strm;
1606 hStdErr = fd[1];
1607
1608 return pStdErr;
1609 }
1610
1611
1612 #endif /* PLATFORM_WINDOWS */
1613
1614 status_t Process::copy_env()
1615 {
1616 lltl::parray<envvar_t> env;
1617 LSPString k, v;
1618
1619 #ifdef PLATFORM_WINDOWS
1620 for (WCHAR *item = GetEnvironmentStringsW(); (*item) != 0; )
1621 {
1622 size_t len = wcslen(item);
1623
1624 // Fetch environment variable
1625 if (!k.set_utf16(item, len))
1626 {
1627 destroy_env(&env);
1628 return STATUS_NO_MEM;
1629 }
1630 item += (len + 1); // length + terminating character
1631 #else
1632 for (char **item=environ; *item != NULL; ++item)
1633 {
1634 // Fetch environment variable
1635 if (!k.set_native(*item))
1636 {
1637 destroy_env(&env);
1638 return STATUS_NO_MEM;
1639 }
1640 #endif /* PLATFORM_WINDOWS */
1641
1642 // Parse record
1643 ssize_t idx = k.index_of('=');
1644 if (idx >= 0)
1645 {
1646 if (!v.set(&k, idx+1))
1647 {
1648 destroy_env(&env);
1649 return STATUS_NO_MEM;
1650 }
1651 if (!k.truncate(idx))
1652 {
1653 destroy_env(&env);
1654 return STATUS_NO_MEM;
1655 }
1656 }
1657
1658 // Allocate && add env var
1659 envvar_t *var = new envvar_t();
1660 if ((var == NULL) || (!env.add(var)))
1661 {
1662 destroy_env(&env);
1663 return STATUS_NO_MEM;
1664 }
1665
1666 // Store value to env
1667 var->name.swap(&k);
1668 var->value.swap(&v);
1669
1670 } // for
1671
1672 // Commit result
1673 vEnv.swap(&env);
1674 destroy_env(&env);
1675
1676 return STATUS_OK;
1677 }
1678 } /* namespace ipc */
1679 } /* namespace lsp */