?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cid#1640468 Dereference after null check
[LibreOffice.git] / sal / osl / unx / process.cxx
blob13320263c65aba1a6cb6bf8ce1cb6afee74af675
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21 #include <rtl/ustring.hxx>
22
23 #include <cassert>
24 #include <fcntl.h>
25 #include <limits.h>
26 #include <sys/time.h>
27 #include <sys/wait.h>
28 #include <unistd.h>
29
30 /*
31 * ToDo:
32 * - cleanup of process status things
33 * - cleanup of process spawning
34 * - cleanup of resource transfer
35 */
36
37 #if defined(__sun)
38 // The procfs may only be used without LFS in 32bits.
39 # ifdef _FILE_OFFSET_BITS
40 # undef _FILE_OFFSET_BITS
41 # endif
42 #endif
43
44 #if defined(FREEBSD) || defined(NETBSD) || defined(DRAGONFLY)
45 #include <machine/param.h>
46 #endif
47
48 #ifdef IOS
49 #include <signal.h>
50 #endif
51
52 #include "system.hxx"
53 #include "unixerrnostring.hxx"
54 #if defined(__sun)
55 # include <sys/procfs.h>
56 #endif
57 #include <osl/diagnose.h>
58 #include <osl/mutex.h>
59 #include <osl/process.h>
60 #include <osl/conditn.h>
61 #include <osl/thread.h>
62 #include <osl/file.h>
63 #include <osl/file.hxx>
64 #include <sal/log.hxx>
65
66 #include "createfilehandlefromfd.hxx"
67 #include "file_url.hxx"
68 #include "readwrite_helper.hxx"
69 #include "secimpl.hxx"
70
71 #define MAX_ARGS 255
72 #define MAX_ENVS 255
73
74 namespace
75 {
76
77 struct oslProcessImpl {
78 pid_t m_pid;
79 oslCondition m_terminated;
80 int m_status;
81 oslProcessImpl* m_pnext;
82 };
83
84 struct ProcessData
85 {
86 const char* m_pszArgs[MAX_ARGS + 1];
87 const char* m_pszDir;
88 char* m_pszEnv[MAX_ENVS + 1];
89 uid_t m_uid;
90 gid_t m_gid;
91 char* m_name;
92 oslCondition m_started;
93 oslProcessImpl* m_pProcImpl;
94 oslFileHandle *m_pInputWrite;
95 oslFileHandle *m_pOutputRead;
96 oslFileHandle *m_pErrorRead;
97 };
98
99 oslProcessImpl* ChildList;
100 oslMutex ChildListMutex;
101
102 } //Anonymous namespace
103
104 static oslProcessError osl_psz_executeProcess(char *pszImageName,
105 char *pszArguments[],
106 oslProcessOption Options,
107 oslSecurity Security,
108 char *pszDirectory,
109 char *pszEnvironments[],
110 oslProcess *pProcess,
111 oslFileHandle *pInputWrite,
112 oslFileHandle *pOutputRead,
113 oslFileHandle *pErrorRead );
114
115 extern "C" {
116
117 static void ChildStatusProc(void *pData)
118 {
119 osl_setThreadName("osl_executeProcess");
120
121 pid_t pid = -1;
122 int status = 0;
123 int channel[2] = { -1, -1 };
124 ProcessData data;
125 ProcessData *pdata;
126 int stdOutput[2] = { -1, -1 }, stdInput[2] = { -1, -1 }, stdError[2] = { -1, -1 };
127
128 pdata = static_cast<ProcessData *>(pData);
129
130 /* make a copy of our data, because forking will only copy
131 our local stack of the thread, so the process data will not be accessible
132 in our child process */
133 memcpy(&data, pData, sizeof(data));
134
135 #ifdef NO_CHILD_PROCESSES
136 #define fork() (errno = EINVAL, -1)
137 #endif
138 if (socketpair(AF_UNIX, SOCK_STREAM, 0, channel) == -1)
139 {
140 status = errno;
141 SAL_WARN("sal.osl", "executeProcess socketpair() errno " << status);
142 }
143
144 (void) fcntl(channel[0], F_SETFD, FD_CLOEXEC);
145 (void) fcntl(channel[1], F_SETFD, FD_CLOEXEC);
146
147 /* Create redirected IO pipes */
148 if ( status == 0 && data.m_pInputWrite && pipe( stdInput ) == -1 )
149 {
150 status = errno;
151 assert(status != 0);
152 SAL_WARN("sal.osl", "executeProcess pipe(stdInput) errno " << status);
153 }
154
155 if ( status == 0 && data.m_pOutputRead && pipe( stdOutput ) == -1 )
156 {
157 status = errno;
158 assert(status != 0);
159 SAL_WARN("sal.osl", "executeProcess pipe(stdOutput) errno " << status);
160 }
161
162 if ( status == 0 && data.m_pErrorRead && pipe( stdError ) == -1 )
163 {
164 status = errno;
165 assert(status != 0);
166 SAL_WARN("sal.osl", "executeProcess pipe(stdError) errno " << status);
167 }
168
169 if ( (status == 0) && ((pid = fork()) == 0) )
170 {
171 /* Child */
172 int chstatus = 0;
173 int errno_copy;
174
175 if (channel[0] != -1) close(channel[0]);
176
177 if ((data.m_uid != uid_t(-1)) && ((data.m_uid != getuid()) || (data.m_gid != getgid())))
178 {
179 OSL_ASSERT(geteuid() == 0); /* must be root */
180
181 if (! INIT_GROUPS(data.m_name, data.m_gid) || (setuid(data.m_uid) != 0))
182 {
183 // ignore; can't do much about it here after fork
184 }
185
186 unsetenv("HOME");
187 }
188
189 if (data.m_pszDir)
190 chstatus = chdir(data.m_pszDir);
191
192 if (chstatus == 0 && ((data.m_uid == uid_t(-1)) || ((data.m_uid == getuid()) && (data.m_gid == getgid()))))
193 {
194 int i;
195 for (i = 0; data.m_pszEnv[i] != nullptr; i++)
196 {
197 if (strchr(data.m_pszEnv[i], '=') == nullptr)
198 {
199 unsetenv(data.m_pszEnv[i]); /*TODO: check error return*/
200 }
201 else
202 {
203 putenv(data.m_pszEnv[i]); /*TODO: check error return*/
204 }
205 }
206
207 /* Connect std IO to pipe ends */
208
209 /* Write end of stdInput not used in child process */
210 if (stdInput[1] != -1) close( stdInput[1] );
211
212 /* Read end of stdOutput not used in child process */
213 if (stdOutput[0] != -1) close( stdOutput[0] );
214
215 /* Read end of stdError not used in child process */
216 if (stdError[0] != -1) close( stdError[0] );
217
218 /* Redirect pipe ends to std IO */
219
220 if ( stdInput[0] != STDIN_FILENO )
221 {
222 dup2( stdInput[0], STDIN_FILENO );
223 if (stdInput[0] != -1) close( stdInput[0] );
224 }
225
226 if ( stdOutput[1] != STDOUT_FILENO )
227 {
228 dup2( stdOutput[1], STDOUT_FILENO );
229 if (stdOutput[1] != -1) close( stdOutput[1] );
230 }
231
232 if ( stdError[1] != STDERR_FILENO )
233 {
234 dup2( stdError[1], STDERR_FILENO );
235 if (stdError[1] != -1) close( stdError[1] );
236 }
237
238 // No need to check the return value of execv. If we return from
239 // it, an error has occurred.
240 execv(data.m_pszArgs[0], const_cast<char **>(data.m_pszArgs));
241 }
242
243 /* if we reach here, something went wrong */
244 errno_copy = errno;
245 if ( !safeWrite(channel[1], &errno_copy, sizeof(errno_copy)) )
246 {
247 // ignore; can't do much about it here after fork
248 }
249
250 if ( channel[1] != -1 )
251 close(channel[1]);
252
253 _exit(255);
254 }
255 else
256 { /* Parent */
257 int i = -1;
258 if (channel[1] != -1) close(channel[1]);
259
260 /* Close unused pipe ends */
261 if (stdInput[0] != -1) close( stdInput[0] );
262 if (stdOutput[1] != -1) close( stdOutput[1] );
263 if (stdError[1] != -1) close( stdError[1] );
264
265 if (pid > 0)
266 {
267 while ((i = read(channel[0], &status, sizeof(status))) < 0)
268 {
269 if (errno != EINTR)
270 break;
271 }
272 }
273
274 if (channel[0] != -1) close(channel[0]);
275
276 if ((pid > 0) && (i == 0))
277 {
278 pid_t child_pid;
279 osl_acquireMutex(ChildListMutex);
280
281 pdata->m_pProcImpl->m_pid = pid;
282 pdata->m_pProcImpl->m_pnext = ChildList;
283 ChildList = pdata->m_pProcImpl;
284
285 /* Store used pipe ends in data structure */
286
287 if ( pdata->m_pInputWrite )
288 *(pdata->m_pInputWrite) = osl::detail::createFileHandleFromFD( stdInput[1] );
289
290 if ( pdata->m_pOutputRead )
291 *(pdata->m_pOutputRead) = osl::detail::createFileHandleFromFD( stdOutput[0] );
292
293 if ( pdata->m_pErrorRead )
294 *(pdata->m_pErrorRead) = osl::detail::createFileHandleFromFD( stdError[0] );
295
296 osl_releaseMutex(ChildListMutex);
297
298 osl_setCondition(pdata->m_started);
299
300 do
301 {
302 child_pid = waitpid(pid, &status, 0);
303 } while ( 0 > child_pid && EINTR == errno );
304
305 if ( child_pid < 0)
306 {
307 SAL_WARN("sal.osl", "Failed to wait for child process: " << UnixErrnoString(errno));
308
309 /*
310 We got another error than EINTR. Anyway we have to wake up the
311 waiting thread under any circumstances */
312
313 child_pid = pid;
314 }
315
316 if ( child_pid > 0 )
317 {
318 oslProcessImpl* pChild;
319
320 osl_acquireMutex(ChildListMutex);
321
322 pChild = ChildList;
323
324 /* check if it is one of our child processes */
325 while (pChild != nullptr)
326 {
327 if (pChild->m_pid == child_pid)
328 {
329 if (WIFEXITED(status))
330 pChild->m_status = WEXITSTATUS(status);
331 else if (WIFSIGNALED(status))
332 pChild->m_status = 128 + WTERMSIG(status);
333 else
334 pChild->m_status = -1;
335
336 // coverity[lock_order : FALSE] - incorrect report of lock order error
337 osl_setCondition(pChild->m_terminated);
338 }
339
340 pChild = pChild->m_pnext;
341 }
342
343 osl_releaseMutex(ChildListMutex);
344 }
345 }
346 else
347 {
348 SAL_WARN("sal.osl", "ChildStatusProc : starting '" << data.m_pszArgs[0] << "' failed");
349 SAL_WARN("sal.osl", "Failed to launch child process, child reports " << UnixErrnoString(status));
350
351 /* Close pipe ends */
352 if ( pdata->m_pInputWrite )
353 *pdata->m_pInputWrite = nullptr;
354
355 if ( pdata->m_pOutputRead )
356 *pdata->m_pOutputRead = nullptr;
357
358 if ( pdata->m_pErrorRead )
359 *pdata->m_pErrorRead = nullptr;
360
361 if (stdInput[1] != -1) close( stdInput[1] );
362 if (stdOutput[0] != -1) close( stdOutput[0] );
363 if (stdError[0] != -1) close( stdError[0] );
364
365 /* if pid > 0 then a process was created, even if it later failed
366 e.g. bash searching for a command to execute, and we still
367 need to clean it up to avoid "defunct" processes */
368 if (pid > 0)
369 {
370 pid_t child_pid;
371 do
372 {
373 child_pid = waitpid(pid, &status, 0);
374 } while ( 0 > child_pid && EINTR == errno );
375 }
376
377 /* notify (and unblock) parent thread */
378 osl_setCondition(pdata->m_started);
379 }
380 }
381 }
382
383 }
384
385 oslProcessError SAL_CALL osl_executeProcess_WithRedirectedIO(
386 rtl_uString *ustrImageName,
387 rtl_uString *ustrArguments[],
388 sal_uInt32 nArguments,
389 oslProcessOption Options,
390 oslSecurity Security,
391 rtl_uString *ustrWorkDir,
392 rtl_uString *ustrEnvironment[],
393 sal_uInt32 nEnvironmentVars,
394 oslProcess *pProcess,
395 oslFileHandle *pInputWrite,
396 oslFileHandle *pOutputRead,
397 oslFileHandle *pErrorRead
398 )
399 {
400 OUString image;
401 if (ustrImageName == nullptr)
402 {
403 if (nArguments == 0)
404 {
405 return osl_Process_E_InvalidError;
406 }
407 image = OUString::unacquired(ustrArguments);
408 }
409 else
410 {
411 osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL(
412 OUString::unacquired(&ustrImageName), image);
413 if (e != osl::FileBase::E_None)
414 {
415 SAL_INFO(
416 "sal.osl",
417 "getSystemPathFromFileURL("
418 << OUString::unacquired(&ustrImageName)
419 << ") failed with " << e);
420 return osl_Process_E_Unknown;
421 }
422 }
423
424 if ((Options & osl_Process_SEARCHPATH) != 0)
425 {
426 OUString path;
427 if (osl::detail::find_in_PATH(image, path))
428 {
429 image = path;
430 }
431 }
432
433 oslProcessError Error;
434 char* pszWorkDir=nullptr;
435 char** pArguments=nullptr;
436 char** pEnvironment=nullptr;
437 unsigned int idx;
438
439 char szImagePath[PATH_MAX] = "";
440 if (!image.isEmpty()
441 && (UnicodeToText(
442 szImagePath, SAL_N_ELEMENTS(szImagePath), image.getStr(),
443 image.getLength())
444 == 0))
445 {
446 int e = errno;
447 SAL_INFO("sal.osl", "UnicodeToText(" << image << ") failed with " << e);
448 return osl_Process_E_Unknown;
449 }
450
451 char szWorkDir[PATH_MAX] = "";
452 if ( ustrWorkDir != nullptr && ustrWorkDir->length )
453 {
454 oslFileError e = FileURLToPath( szWorkDir, PATH_MAX, ustrWorkDir );
455 if (e != osl_File_E_None)
456 {
457 SAL_INFO(
458 "sal.osl",
459 "FileURLToPath(" << OUString::unacquired(&ustrWorkDir)
460 << ") failed with " << e);
461 return osl_Process_E_Unknown;
462 }
463 pszWorkDir = szWorkDir;
464 }
465
466 if ( nArguments > 0 )
467 {
468 pArguments = static_cast<char**>(malloc( ( nArguments + 2 ) * sizeof(char*) ));
469 }
470
471 for ( idx = 0 ; idx < nArguments ; ++idx )
472 {
473 rtl_String* strArg =nullptr;
474
475 rtl_uString2String( &strArg,
476 rtl_uString_getStr(ustrArguments[idx]),
477 rtl_uString_getLength(ustrArguments[idx]),
478 osl_getThreadTextEncoding(),
479 OUSTRING_TO_OSTRING_CVTFLAGS );
480
481 pArguments[idx]=strdup(rtl_string_getStr(strArg));
482 rtl_string_release(strArg);
483 pArguments[idx+1]=nullptr;
484 }
485
486 for ( idx = 0 ; idx < nEnvironmentVars ; ++idx )
487 {
488 rtl_String* strEnv=nullptr;
489
490 if ( pEnvironment == nullptr )
491 {
492 pEnvironment = static_cast<char**>(malloc( ( nEnvironmentVars + 2 ) * sizeof(char*) ));
493 }
494
495 rtl_uString2String( &strEnv,
496 rtl_uString_getStr(ustrEnvironment[idx]),
497 rtl_uString_getLength(ustrEnvironment[idx]),
498 osl_getThreadTextEncoding(),
499 OUSTRING_TO_OSTRING_CVTFLAGS );
500
501 pEnvironment[idx]=strdup(rtl_string_getStr(strEnv));
502 rtl_string_release(strEnv);
503 pEnvironment[idx+1]=nullptr;
504 }
505
506 Error = osl_psz_executeProcess(szImagePath,
507 pArguments,
508 Options,
509 Security,
510 pszWorkDir,
511 pEnvironment,
512 pProcess,
513 pInputWrite,
514 pOutputRead,
515 pErrorRead
516 );
517
518 if ( pArguments != nullptr )
519 {
520 for ( idx = 0 ; idx < nArguments ; ++idx )
521 {
522 if ( pArguments[idx] != nullptr )
523 {
524 free(pArguments[idx]);
525 }
526 }
527 free(pArguments);
528 }
529
530 if ( pEnvironment != nullptr )
531 {
532 for ( idx = 0 ; idx < nEnvironmentVars ; ++idx )
533 {
534 if ( pEnvironment[idx] != nullptr )
535 {
536 free(pEnvironment[idx]);
537 }
538 }
539 free(pEnvironment);
540 }
541
542 return Error;
543 }
544
545 oslProcessError SAL_CALL osl_executeProcess(
546 rtl_uString *ustrImageName,
547 rtl_uString *ustrArguments[],
548 sal_uInt32 nArguments,
549 oslProcessOption Options,
550 oslSecurity Security,
551 rtl_uString *ustrWorkDir,
552 rtl_uString *ustrEnvironment[],
553 sal_uInt32 nEnvironmentVars,
554 oslProcess *pProcess
555 )
556 {
557 return osl_executeProcess_WithRedirectedIO(
558 ustrImageName,
559 ustrArguments,
560 nArguments,
561 Options,
562 Security,
563 ustrWorkDir,
564 ustrEnvironment,
565 nEnvironmentVars,
566 pProcess,
567 nullptr,
568 nullptr,
569 nullptr
570 );
571 }
572
573 oslProcessError osl_psz_executeProcess(char *pszImageName,
574 char *pszArguments[],
575 oslProcessOption Options,
576 oslSecurity Security,
577 char *pszDirectory,
578 char *pszEnvironments[],
579 oslProcess *pProcess,
580 oslFileHandle *pInputWrite,
581 oslFileHandle *pOutputRead,
582 oslFileHandle *pErrorRead
583 )
584 {
585 int i;
586 ProcessData Data;
587 oslThread hThread;
588
589 memset(&Data,0,sizeof(ProcessData));
590 Data.m_pInputWrite = pInputWrite;
591 Data.m_pOutputRead = pOutputRead;
592 Data.m_pErrorRead = pErrorRead;
593
594 OSL_ASSERT(pszImageName != nullptr);
595
596 if ( pszImageName == nullptr )
597 {
598 return osl_Process_E_NotFound;
599 }
600
601 Data.m_pszArgs[0] = strdup(pszImageName);
602 Data.m_pszArgs[1] = nullptr;
603
604 if ( pszArguments != nullptr )
605 {
606 for (i = 0; ((i + 2) < MAX_ARGS) && (pszArguments[i] != nullptr); i++)
607 Data.m_pszArgs[i+1] = strdup(pszArguments[i]);
608 Data.m_pszArgs[i+2] = nullptr;
609 }
610
611 Data.m_pszDir = (pszDirectory != nullptr) ? strdup(pszDirectory) : nullptr;
612
613 if (pszEnvironments != nullptr)
614 {
615 for (i = 0; ((i + 1) < MAX_ENVS) && (pszEnvironments[i] != nullptr); i++)
616 Data.m_pszEnv[i] = strdup(pszEnvironments[i]);
617 Data.m_pszEnv[i+1] = nullptr;
618 }
619 else
620 Data.m_pszEnv[0] = nullptr;
621
622 if (Security != nullptr)
623 {
624 Data.m_uid = static_cast<oslSecurityImpl*>(Security)->m_pPasswd.pw_uid;
625 Data.m_gid = static_cast<oslSecurityImpl*>(Security)->m_pPasswd.pw_gid;
626 Data.m_name = static_cast<oslSecurityImpl*>(Security)->m_pPasswd.pw_name;
627 }
628 else
629 Data.m_uid = uid_t(-1);
630
631 Data.m_pProcImpl = static_cast<oslProcessImpl*>(malloc(sizeof(oslProcessImpl)));
632 Data.m_pProcImpl->m_pid = 0;
633 Data.m_pProcImpl->m_terminated = osl_createCondition();
634 Data.m_pProcImpl->m_pnext = nullptr;
635
636 if (ChildListMutex == nullptr)
637 ChildListMutex = osl_createMutex();
638
639 Data.m_started = osl_createCondition();
640
641 hThread = osl_createThread(ChildStatusProc, &Data);
642
643 if (hThread != nullptr)
644 {
645 osl_waitCondition(Data.m_started, nullptr);
646 }
647 osl_destroyCondition(Data.m_started);
648
649 for (i = 0; Data.m_pszArgs[i] != nullptr; i++)
650 free(const_cast<char *>(Data.m_pszArgs[i]));
651
652 for (i = 0; Data.m_pszEnv[i] != nullptr; i++)
653 free(Data.m_pszEnv[i]);
654
655 if ( Data.m_pszDir != nullptr )
656 {
657 free(const_cast<char *>(Data.m_pszDir));
658 }
659
660 osl_destroyThread(hThread);
661
662 if (Data.m_pProcImpl->m_pid != 0)
663 {
664 assert(hThread != nullptr);
665
666 *pProcess = Data.m_pProcImpl;
667
668 if (Options & osl_Process_WAIT)
669 osl_joinProcess(*pProcess);
670
671 return osl_Process_E_None;
672 }
673
674 osl_destroyCondition(Data.m_pProcImpl->m_terminated);
675 free(Data.m_pProcImpl);
676
677 return osl_Process_E_Unknown;
678 }
679
680 oslProcessError SAL_CALL osl_terminateProcess(oslProcess Process)
681 {
682 if (Process == nullptr)
683 return osl_Process_E_Unknown;
684
685 if (kill(static_cast<oslProcessImpl*>(Process)->m_pid, SIGKILL) != 0)
686 {
687 switch (errno)
688 {
689 case EPERM:
690 return osl_Process_E_NoPermission;
691
692 case ESRCH:
693 return osl_Process_E_NotFound;
694
695 default:
696 return osl_Process_E_Unknown;
697 }
698 }
699
700 return osl_Process_E_None;
701 }
702
703 oslProcess SAL_CALL osl_getProcess(oslProcessIdentifier Ident)
704 {
705 oslProcessImpl *pProcImpl;
706
707 if (kill(Ident, 0) != -1)
708 {
709 oslProcessImpl* pChild;
710
711 if (ChildListMutex == nullptr)
712 ChildListMutex = osl_createMutex();
713
714 osl_acquireMutex(ChildListMutex);
715
716 pChild = ChildList;
717
718 /* check if it is one of our child processes */
719 while (pChild != nullptr)
720 {
721 if (Ident == static_cast<sal_uInt32>(pChild->m_pid))
722 break;
723
724 pChild = pChild->m_pnext;
725 }
726
727 pProcImpl = static_cast<oslProcessImpl*>(malloc(sizeof(oslProcessImpl)));
728 pProcImpl->m_pid = Ident;
729 pProcImpl->m_terminated = osl_createCondition();
730
731 if (pChild != nullptr)
732 {
733 /* process is a child so insert into list */
734 pProcImpl->m_pnext = pChild->m_pnext;
735 pChild->m_pnext = pProcImpl;
736
737 pProcImpl->m_status = pChild->m_status;
738
739 // coverity[lock_order : FALSE] - incorrect report of lock order error
740 if (osl_checkCondition(pChild->m_terminated))
741 {
742 // coverity[lock_order : FALSE] - incorrect report of lock order error
743 osl_setCondition(pProcImpl->m_terminated);
744 }
745 }
746 else
747 pProcImpl->m_pnext = nullptr;
748
749 osl_releaseMutex(ChildListMutex);
750 }
751 else
752 pProcImpl = nullptr;
753
754 return pProcImpl;
755 }
756
757 void SAL_CALL osl_freeProcessHandle(oslProcess Process)
758 {
759 if (Process == nullptr)
760 return;
761
762 oslProcessImpl *pChild, *pPrev = nullptr;
763
764 OSL_ASSERT(ChildListMutex != nullptr);
765
766 if ( ChildListMutex == nullptr )
767 {
768 return;
769 }
770
771 osl_acquireMutex(ChildListMutex);
772
773 pChild = ChildList;
774
775 /* remove process from child list */
776 while (pChild != nullptr)
777 {
778 if (pChild == static_cast<oslProcessImpl*>(Process))
779 {
780 if (pPrev != nullptr)
781 pPrev->m_pnext = pChild->m_pnext;
782 else
783 ChildList = pChild->m_pnext;
784
785 break;
786 }
787
788 pPrev = pChild;
789 pChild = pChild->m_pnext;
790 }
791
792 osl_releaseMutex(ChildListMutex);
793
794 osl_destroyCondition(static_cast<oslProcessImpl*>(Process)->m_terminated);
795
796 free(Process);
797 }
798
799 #if defined(LINUX)
800 namespace {
801
802 struct osl_procStat
803 {
804 /* from 'stat' */
805 pid_t pid; /* pid */
806 char command[16]; /* 'argv[0]' */ /* mfe: it all right char comm[16] in kernel! */
807 char state; /* state (running, stopped, ...) */
808 pid_t ppid; /* parent pid */
809 pid_t pgrp; /* parent group */
810 int session; /* session ID */
811 int tty; /* no of tty */
812 pid_t tpgid; /* group of process owning the tty */
813 unsigned long flags; /* flags dunno */
814 unsigned long minflt; /* minor page faults */
815 unsigned long cminflt; /* minor page faults with children */
816 unsigned long majflt; /* major page faults */
817 unsigned long cmajflt; /* major page faults with children */
818 unsigned long utime; /* no of jiffies in user mode */
819 unsigned long stime; /* no of jiffies in kernel mode */
820 unsigned long cutime; /* no of jiffies in user mode with children */
821 unsigned long cstime; /* no of jiffies in kernel mode with children */
822 unsigned long priority; /* nice value + 15 (kernel scheduling prio)*/
823 long nice; /* nice value */
824 long timeout; /* no of jiffies of next process timeout */
825 long itrealvalue; /* no jiffies before next SIGALRM */
826 unsigned long starttime; /* process started this no of jiffies after boot */
827 unsigned long vsize; /* virtual memory size (in bytes) */
828 long rss; /* resident set size (in pages) */
829 unsigned long rss_rlim; /* rss limit (in bytes) */
830 unsigned long startcode; /* address above program text can run */
831 unsigned long endcode; /* address below program text can run */
832 unsigned long startstack; /* address of start of stack */
833 unsigned long kstkesp; /* current value of 'esp' (stack pointer) */
834 unsigned long kstkeip; /* current value of 'eip' (instruction pointer) */
835 /* mfe: Linux > 2.1.7x have more signals (88) */
836 char signal[24]; /* pending signals */
837 char blocked[24]; /* blocked signals */
838 char sigignore[24]; /* ignored signals */
839 char sigcatch[24]; /* caught signals */
840 unsigned long wchan; /* 'channel' the process is waiting in */
841 unsigned long nswap; /* ? */
842 unsigned long cnswap; /* ? */
843
844 /* from 'status' */
845 int ruid; /* real uid */
846 int euid; /* effective uid */
847 int suid; /* saved uid */
848 int fuid; /* file access uid */
849 int rgid; /* real gid */
850 int egid; /* effective gid */
851 int sgid; /* saved gid */
852 int fgid; /* file access gid */
853 unsigned long vm_size; /* like vsize but on kb */
854 unsigned long vm_lock; /* locked pages in kb */
855 unsigned long vm_rss; /* like rss but in kb */
856 unsigned long vm_data; /* data size */
857 unsigned long vm_stack; /* stack size */
858 unsigned long vm_exe; /* executable size */
859 unsigned long vm_lib; /* library size */
860 };
861
862 }
863
864 static bool osl_getProcStat(pid_t pid, struct osl_procStat* procstat)
865 {
866 int fd = 0;
867 bool bRet = false;
868 char name[PATH_MAX + 1];
869 snprintf(name, sizeof(name), "/proc/%u/stat", pid);
870
871 if ((fd = open(name,O_RDONLY)) >=0 )
872 {
873 char* tmp=nullptr;
874 char prstatbuf[512];
875 memset(prstatbuf,0,512);
876 bRet = safeRead(fd, prstatbuf, 511);
877
878 close(fd);
879
880 if (!bRet)
881 return false;
882
883 tmp = strrchr(prstatbuf, ')');
884 if(tmp)
885 {
886 *tmp = '\0';
887
888 memset(procstat->command, 0, sizeof(procstat->command));
889
890 sscanf(prstatbuf, "%d (%15c", &procstat->pid, procstat->command);
891 sscanf(tmp + 2,
892 "%c"
893 "%i %i %i %i %i"
894 "%lu %lu %lu %lu %lu"
895 "%lu %lu %lu %lu"
896 "%lu %li %li %li"
897 "%lu %lu %li %lu"
898 "%lu %lu %lu %lu %lu"
899 "%23s %23s %23s %23s"
900 "%lu %lu %lu",
901 &procstat->state,
902 &procstat->ppid, &procstat->pgrp, &procstat->session, &procstat->tty, &procstat->tpgid,
903 &procstat->flags, &procstat->minflt, &procstat->cminflt, &procstat->majflt, &procstat->cmajflt,
904 &procstat->utime, &procstat->stime, &procstat->cutime, &procstat->cstime,
905 &procstat->priority, &procstat->nice, &procstat->timeout, &procstat->itrealvalue,
906 &procstat->starttime, &procstat->vsize, &procstat->rss, &procstat->rss_rlim,
907 &procstat->startcode, &procstat->endcode, &procstat->startstack, &procstat->kstkesp, &procstat->kstkeip,
908 procstat->signal, procstat->blocked, procstat->sigignore, procstat->sigcatch,
909 &procstat->wchan, &procstat->nswap, &procstat->cnswap
910 );
911 }
912 else
913 {
914 bRet = false;
915 }
916 }
917 return bRet;
918 }
919
920 static bool osl_getProcStatus(pid_t pid, struct osl_procStat* procstat)
921 {
922 int fd = 0;
923 char name[PATH_MAX + 1];
924 bool bRet = false;
925
926 snprintf(name, sizeof(name), "/proc/%u/status", pid);
927
928 if ((fd = open(name,O_RDONLY)) >=0 )
929 {
930 char* tmp=nullptr;
931 char prstatusbuf[512];
932 memset(prstatusbuf,0,512);
933 bRet = safeRead(fd, prstatusbuf, 511);
934
935 close(fd);
936
937 if (!bRet)
938 return false;
939
940 tmp = strstr(prstatusbuf,"Uid:");
941 if(tmp)
942 {
943 sscanf(tmp,"Uid:\t%d\t%d\t%d\t%d",
944 &procstat->ruid, &procstat->euid, &procstat->suid, &procstat->fuid
945 );
946 }
947
948 tmp = strstr(prstatusbuf,"Gid:");
949 if(tmp)
950 {
951 sscanf(tmp,"Gid:\t%d\t%d\t%d\t%d",
952 &procstat->rgid, &procstat->egid, &procstat->sgid, &procstat->fgid
953 );
954 }
955
956 tmp = strstr(prstatusbuf,"VmSize:");
957 if(tmp)
958 {
959 sscanf(tmp,
960 "VmSize: %lu kB\n"
961 "VmLck: %lu kB\n"
962 "VmRSS: %lu kB\n"
963 "VmData: %lu kB\n"
964 "VmStk: %lu kB\n"
965 "VmExe: %lu kB\n"
966 "VmLib: %lu kB\n",
967 &procstat->vm_size, &procstat->vm_lock, &procstat->vm_rss, &procstat->vm_data,
968 &procstat->vm_stack, &procstat->vm_exe, &procstat->vm_lib
969 );
970 }
971
972 tmp = strstr(prstatusbuf,"SigPnd:");
973 if(tmp)
974 {
975 sscanf(tmp, "SigPnd: %23s SigBlk: %23s SigIgn: %23s %*s %23s",
976 procstat->signal, procstat->blocked, procstat->sigignore, procstat->sigcatch
977 );
978 }
979 }
980 return bRet;
981 }
982
983 #endif
984
985 oslProcessError SAL_CALL osl_getProcessInfo(oslProcess Process, oslProcessData Fields, oslProcessInfo* pInfo)
986 {
987 pid_t pid;
988
989 if (Process == nullptr)
990 pid = getpid();
991 else
992 pid = static_cast<oslProcessImpl*>(Process)->m_pid;
993
994 if (! pInfo || (pInfo->Size != sizeof(oslProcessInfo)))
995 return osl_Process_E_Unknown;
996
997 pInfo->Fields = 0;
998
999 if (Fields & osl_Process_IDENTIFIER)
1000 {
1001 pInfo->Ident = pid;
1002 pInfo->Fields |= osl_Process_IDENTIFIER;
1003 }
1004
1005 if (Fields & osl_Process_EXITCODE)
1006 {
1007 if ((Process != nullptr) &&
1008 osl_checkCondition(static_cast<oslProcessImpl*>(Process)->m_terminated))
1009 {
1010 pInfo->Code = static_cast<oslProcessImpl*>(Process)->m_status;
1011 pInfo->Fields |= osl_Process_EXITCODE;
1012 }
1013 }
1014
1015 if (Fields & (osl_Process_HEAPUSAGE | osl_Process_CPUTIMES))
1016 {
1017
1018 #if defined(__sun)
1019
1020 int fd;
1021 char name[PATH_MAX + 1];
1022
1023 snprintf(name, sizeof(name), "/proc/%ld", (long)pid);
1024
1025 if ((fd = open(name, O_RDONLY)) >= 0)
1026 {
1027 prstatus_t prstatus;
1028
1029 if (ioctl(fd, PIOCSTATUS, &prstatus) >= 0)
1030 {
1031 if (Fields & osl_Process_CPUTIMES)
1032 {
1033 pInfo->UserTime.Seconds = prstatus.pr_utime.tv_sec;
1034 pInfo->UserTime.Nanosec = prstatus.pr_utime.tv_nsec;
1035 pInfo->SystemTime.Seconds = prstatus.pr_stime.tv_sec;
1036 pInfo->SystemTime.Nanosec = prstatus.pr_stime.tv_nsec;
1037
1038 pInfo->Fields |= osl_Process_CPUTIMES;
1039 }
1040
1041 if (Fields & osl_Process_HEAPUSAGE)
1042 {
1043 pInfo->HeapUsage = prstatus.pr_brksize;
1044
1045 pInfo->Fields |= osl_Process_HEAPUSAGE;
1046 }
1047
1048 close(fd);
1049
1050 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1051 }
1052 else
1053 close(fd);
1054 }
1055
1056 #elif defined(LINUX)
1057
1058 if ( (Fields & osl_Process_CPUTIMES) || (Fields & osl_Process_HEAPUSAGE) )
1059 {
1060 struct osl_procStat procstat;
1061 memset(&procstat,0,sizeof(procstat));
1062
1063 if ( (Fields & osl_Process_CPUTIMES) && osl_getProcStat(pid, &procstat) )
1064 {
1065 /*
1066 * mfe:
1067 * We calculate only time of the process proper.
1068 * Threads are processes, we do not consider their time here!
1069 * (For this, cutime and cstime should be used, it seems not
1070 * to work in 2.0.36)
1071 */
1072
1073 long clktck;
1074 unsigned long hz;
1075 unsigned long userseconds;
1076 unsigned long systemseconds;
1077
1078 clktck = sysconf(_SC_CLK_TCK);
1079 if (clktck <= 0) {
1080 return osl_Process_E_Unknown;
1081 }
1082 hz = static_cast<unsigned long>(clktck);
1083
1084 userseconds = procstat.utime/hz;
1085 systemseconds = procstat.stime/hz;
1086
1087 pInfo->UserTime.Seconds = userseconds;
1088 pInfo->UserTime.Nanosec = procstat.utime - (userseconds * hz);
1089 pInfo->SystemTime.Seconds = systemseconds;
1090 pInfo->SystemTime.Nanosec = procstat.stime - (systemseconds * hz);
1091
1092 pInfo->Fields |= osl_Process_CPUTIMES;
1093 }
1094
1095 if ( (Fields & osl_Process_HEAPUSAGE) && osl_getProcStatus(pid, &procstat) )
1096 {
1097 /*
1098 * mfe:
1099 * vm_data (found in status) shows the size of the data segment
1100 * it a rough approximation of the core heap size
1101 */
1102 pInfo->HeapUsage = procstat.vm_data*1024;
1103
1104 pInfo->Fields |= osl_Process_HEAPUSAGE;
1105 }
1106 }
1107
1108 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1109 #endif
1110
1111 }
1112
1113 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1114 }
1115
1116 /** Helper function for osl_joinProcessWithTimeout
1117 */
1118
1119 static bool is_timeout(const struct timeval* tend)
1120 {
1121 struct timeval tcurrent;
1122 gettimeofday(&tcurrent, nullptr);
1123 return (tcurrent.tv_sec >= tend->tv_sec);
1124 }
1125
1126 /* kill(pid, 0) is useful for checking if a
1127 process is still alive, but remember that
1128 kill even returns 0 if the process is already
1129 a zombie. */
1130
1131 static bool is_process_dead(pid_t pid)
1132 {
1133 return ((kill(pid, 0) == -1) && (ESRCH == errno));
1134 }
1135
1136 oslProcessError SAL_CALL osl_joinProcessWithTimeout(oslProcess Process, const TimeValue* pTimeout)
1137 {
1138 oslProcessImpl* pChild = ChildList;
1139 oslProcessError osl_error = osl_Process_E_None;
1140
1141 OSL_PRECOND(Process, "osl_joinProcess: Invalid parameter");
1142 OSL_ASSERT(ChildListMutex);
1143
1144 if (Process == nullptr || ChildListMutex == nullptr)
1145 return osl_Process_E_Unknown;
1146
1147 osl_acquireMutex(ChildListMutex);
1148
1149 /* check if process is a child of ours */
1150 while (pChild != nullptr)
1151 {
1152 if (pChild == static_cast<oslProcessImpl*>(Process))
1153 break;
1154
1155 pChild = pChild->m_pnext;
1156 }
1157
1158 osl_releaseMutex(ChildListMutex);
1159
1160 if (pChild != nullptr)
1161 {
1162 oslConditionResult cond_res = osl_waitCondition(pChild->m_terminated, pTimeout);
1163
1164 if (cond_res == osl_cond_result_timeout)
1165 osl_error = osl_Process_E_TimedOut;
1166 else if (cond_res != osl_cond_result_ok)
1167 osl_error = osl_Process_E_Unknown;
1168 }
1169 else /* alien process; StatusThread will not be able
1170 to set the condition terminated */
1171 {
1172 pid_t pid = static_cast<oslProcessImpl*>(Process)->m_pid;
1173
1174 if (pTimeout)
1175 {
1176 bool timeout = false;
1177 struct timeval tend;
1178
1179 gettimeofday(&tend, nullptr);
1180
1181 tend.tv_sec += pTimeout->Seconds;
1182
1183 while (!is_process_dead(pid) && !(timeout = is_timeout(&tend)))
1184 sleep(1);
1185
1186 if (timeout)
1187 osl_error = osl_Process_E_TimedOut;
1188 }
1189 else /* infinite */
1190 {
1191 while (!is_process_dead(pid))
1192 sleep(1);
1193 }
1194 }
1195 return osl_error;
1196 }
1197
1198 oslProcessError SAL_CALL osl_joinProcess(oslProcess Process)
1199 {
1200 return osl_joinProcessWithTimeout(Process, nullptr);
1201 }
1202
1203 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE