?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sal / osl / unx / process.c
blob2eaea19eddc2639852aec3ae3533fdebcf86f385
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: process.c,v $
10 * $Revision: 1.44 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31
32 /*
33 * ToDo:
34 * - cleanup of process status things
35 * - cleanup of process spawning
36 * - cleanup of resource transfer
37 */
38
39 #if defined(SOLARIS)
40 // The procfs may only be used without LFS in 32bits.
41 # ifdef _FILE_OFFSET_BITS
42 # undef _FILE_OFFSET_BITS
43 # endif
44 #endif
45
46
47 #ifdef FREEBSD
48 #include <machine/param.h>
49 #endif
50
51 #include "system.h"
52 #if defined(SOLARIS) || defined(IRIX)
53 # include <sys/procfs.h>
54 #endif
55 #include <osl/diagnose.h>
56 #include <osl/mutex.h>
57
58 #ifndef _OSL_CONDITN_H_
59 #include <osl/conditn.h>
60 #endif
61 #include <osl/thread.h>
62 #include <osl/file.h>
63 #include <osl/signal.h>
64 #include <rtl/alloc.h>
65
66 #include <grp.h>
67
68 #include "procimpl.h"
69 #include "sockimpl.h"
70 #include "secimpl.h"
71
72
73 #define MAX_ARGS 255
74 #define MAX_ENVS 255
75
76 #if defined(MACOSX) || defined(IORESOURCE_TRANSFER_BSD)
77 #define CONTROLLEN (sizeof(struct cmsghdr) + sizeof(int))
78 #endif
79
80 /* implemented in file.c */
81 extern oslFileError FileURLToPath( char *, size_t, rtl_uString* );
82 extern oslFileHandle osl_createFileHandleFromFD( int fd );
83
84 /******************************************************************************
85 *
86 * Data Type Definition
87 *
88 ******************************************************************************/
89
90 typedef struct {
91 int m_hPipe;
92 int m_hConn;
93 sal_Char m_Name[PATH_MAX + 1];
94 } Pipe;
95
96 typedef struct {
97 const sal_Char* m_pszArgs[MAX_ARGS + 1];
98 oslProcessOption m_options;
99 const sal_Char* m_pszDir;
100 sal_Char* m_pszEnv[MAX_ENVS + 1];
101 uid_t m_uid;
102 gid_t m_gid;
103 sal_Char* m_name;
104 oslCondition m_started;
105 oslProcessImpl* m_pProcImpl;
106 oslFileHandle *m_pInputWrite;
107 oslFileHandle *m_pOutputRead;
108 oslFileHandle *m_pErrorRead;
109 } ProcessData;
110
111 typedef struct _oslPipeImpl {
112 int m_Socket;
113 sal_Char m_Name[PATH_MAX + 1];
114 } oslPipeImpl;
115
116
117 /******************************************************************************
118 *
119 * Function Declarations
120 *
121 *****************************************************************************/
122
123 oslProcessError SAL_CALL osl_psz_executeProcess(sal_Char *pszImageName,
124 sal_Char *pszArguments[],
125 oslProcessOption Options,
126 oslSecurity Security,
127 sal_Char *pszDirectory,
128 sal_Char *pszEnvironments[],
129 oslProcess *pProcess,
130 oslFileHandle *pInputWrite,
131 oslFileHandle *pOutputRead,
132 oslFileHandle *pErrorRead );
133
134
135 oslProcessError SAL_CALL osl_searchPath_impl(
136 const sal_Char* pszName,
137 const sal_Char* pszPath,
138 sal_Char Separator,
139 sal_Char *pszBuffer,
140 sal_uInt32 Max);
141
142
143 sal_Bool osl_getFullPath(const sal_Char* pszFilename, sal_Char* pszPath, sal_uInt32 MaxLen);
144
145 static oslProcessImpl* ChildList;
146 static oslMutex ChildListMutex;
147
148 /******************************************************************************
149 Deprecated
150 Old and buggy implementation of osl_searchPath used only by
151 osl_psz_executeProcess.
152 A new implemenation is in file_path_helper.cxx
153 *****************************************************************************/
154
155 oslProcessError SAL_CALL osl_searchPath_impl(const sal_Char* pszName, const sal_Char* pszPath,
156 sal_Char Separator, sal_Char *pszBuffer, sal_uInt32 Max)
157 {
158 sal_Char path[PATH_MAX + 1];
159 sal_Char *pchr;
160
161 path[0] = '\0';
162
163 OSL_ASSERT(pszName != NULL);
164
165 if ( pszName == 0 )
166 {
167 return osl_Process_E_NotFound;
168 }
169
170 if (pszPath == NULL)
171 pszPath = "PATH";
172
173 if (Separator == '\0')
174 Separator = ':';
175
176
177 if ( (pchr = getenv(pszPath)) != 0 )
178 {
179 sal_Char *pstr;
180
181 while (*pchr != '\0')
182 {
183 pstr = path;
184
185 while ((*pchr != '\0') && (*pchr != Separator))
186 *pstr++ = *pchr++;
187
188 if ((pstr > path) && ((*(pstr - 1) != '/')))
189 *pstr++ = '/';
190
191 *pstr = '\0';
192
193 strcat(path, pszName);
194
195 if (access(path, 0) == 0)
196 {
197 char szRealPathBuf[PATH_MAX] = "";
198
199 if( NULL == realpath(path, szRealPathBuf) || (strlen(szRealPathBuf) >= (sal_uInt32)Max))
200 return osl_Process_E_Unknown;
201
202 strcpy(pszBuffer, path);
203
204 return osl_Process_E_None;
205 }
206
207 if (*pchr == Separator)
208 pchr++;
209 }
210 }
211
212 return osl_Process_E_NotFound;
213 }
214
215 /******************************************************************************
216 *
217 * New io resource transfer functions
218 *
219 *****************************************************************************/
220
221
222 /**********************************************
223 sendFdPipe
224 *********************************************/
225
226 static sal_Bool sendFdPipe(int PipeFD, int SocketFD)
227 {
228 sal_Bool bRet = sal_False;
229
230 struct iovec iov[1];
231 struct msghdr msg;
232 char buf[2]; /* send_fd()/recv_fd() 2-byte protocol */
233 int nSend;
234 int RetCode=0;
235
236 #if defined(IOCHANNEL_TRANSFER_BSD)
237
238 OSL_TRACE("IOCHANNEL_TRANSFER_BSD send");
239 /* OSL_TRACE("sending fd %i\n",SocketFD); */
240
241 iov[0].iov_base = buf;
242 iov[0].iov_len = sizeof(buf);
243 msg.msg_iov = iov;
244 msg.msg_iovlen = 1;
245 msg.msg_name = NULL;
246 msg.msg_namelen = 0;
247
248 msg.msg_accrights = (caddr_t) &SocketFD; /* addr of descriptor */
249 msg.msg_accrightslen = sizeof(int); /* pass 1 descriptor */
250 buf[1] = 0; /* zero status means OK */
251 buf[0] = 0; /* null byte flag to recv_fd() */
252
253 #else
254
255 struct cmsghdr* cmptr = (struct cmsghdr*)malloc(CONTROLLEN);
256
257 OSL_TRACE("!!!!!! IOCHANNEL_TRANSFER_BSD_RENO send");
258 /* OSL_TRACE("sending fd %i\n",SocketFD); */
259
260 iov[0].iov_base = buf;
261 iov[0].iov_len = sizeof(buf);
262 msg.msg_iov = iov;
263 msg.msg_iovlen = 1;
264 msg.msg_name = NULL;
265 msg.msg_namelen = 0;
266 msg.msg_control = (caddr_t) cmptr;
267 msg.msg_controllen = CONTROLLEN;
268
269 cmptr->cmsg_level = SOL_SOCKET;
270 cmptr->cmsg_type = SCM_RIGHTS;
271 cmptr->cmsg_len = CONTROLLEN;
272 *(int*)CMSG_DATA(cmptr) = SocketFD;
273
274 #endif
275
276 if ( ( nSend = sendmsg(PipeFD, &msg, 0) ) > 0 )
277 {
278 bRet = sal_True;
279 OSL_TRACE("sendFdPipe : send '%i' bytes\n",nSend);
280
281 }
282 else
283 {
284 OSL_TRACE("sendFdPipe : sending failed (%s)",strerror(errno));
285 }
286
287 nSend=read(PipeFD,&RetCode,sizeof(RetCode));
288
289 if ( nSend > 0 && RetCode == 1 )
290 {
291 OSL_TRACE("sendFdPipe : resource was received\n");
292 }
293 else
294 {
295 OSL_TRACE("sendFdPipe : resource wasn't received\n");
296 }
297
298 #if defined(IOCHANNEL_TRANSFER_BSD_RENO)
299 free(cmptr);
300 #endif
301
302 return bRet;
303 }
304
305 /**********************************************
306 receiveFdPipe
307 *********************************************/
308
309 static oslSocket receiveFdPipe(int PipeFD)
310 {
311 oslSocket pSocket = 0;
312 struct msghdr msghdr;
313 struct iovec iov[1];
314 char buffer[2];
315 sal_Int32 nRead;
316 int newfd=-1;
317 int nRetCode=0;
318 /* char *ptr; */
319
320 #if defined(IOCHANNEL_TRANSFER_BSD)
321
322 OSL_TRACE("IOCHANNEL_TRANSFER_BSD receive\n");
323
324 iov[0].iov_base = buffer;
325 iov[0].iov_len = sizeof(buffer);
326 msghdr.msg_name = NULL;
327 msghdr.msg_namelen = 0;
328 msghdr.msg_iov = iov;
329 msghdr.msg_iovlen = 1;
330 msghdr.msg_accrights = (caddr_t) &newfd; /* addr of descriptor */
331 msghdr.msg_accrightslen = sizeof(int); /* receive 1 descriptor */
332
333 #else
334 struct cmsghdr* cmptr = (struct cmsghdr*)malloc(CONTROLLEN);
335
336 OSL_TRACE(" !!!! IOCHANNEL_TRANSFER_BSD_RENO receive");
337
338 iov[0].iov_base = buffer;
339 iov[0].iov_len = sizeof(buffer);
340 msghdr.msg_name = NULL;
341 msghdr.msg_namelen = 0;
342 msghdr.msg_iov = iov;
343 msghdr.msg_iovlen = 1;
344
345 msghdr.msg_control = (caddr_t) cmptr;
346 msghdr.msg_controllen = CONTROLLEN;
347
348 #endif
349
350
351 #if defined(IOCHANNEL_TRANSFER_BSD)
352
353 if ( ( nRead = recvmsg(PipeFD, &msghdr, 0) ) > 0 )
354 {
355 OSL_TRACE("receiveFdPipe : received '%i' bytes\n",nRead);
356 }
357 #else
358
359 if ( ( ( nRead = recvmsg(PipeFD, &msghdr, 0) ) > 0 ) &&
360 ( msghdr.msg_controllen == CONTROLLEN ) )
361 {
362 OSL_TRACE("receiveFdPipe : received '%i' bytes\n",nRead);
363 newfd = *(int*)CMSG_DATA(cmptr);
364 }
365 #endif
366 else
367 {
368 OSL_TRACE("receiveFdPipe : receiving failed (%s)",strerror(errno));
369 }
370
371 if ( newfd >= 0 )
372 {
373 pSocket = __osl_createSocketImpl(newfd);
374 nRetCode=1;
375 OSL_TRACE("received fd %i\n",newfd);
376 }
377
378 OSL_TRACE("receiveFdPipe : writing back %i",nRetCode);
379 nRead=write(PipeFD,&nRetCode,sizeof(nRetCode));
380
381 #if defined(IOCHANNEL_TRANSFER_BSD_RENO)
382 free(cmptr);
383 #endif
384
385 return pSocket;
386 }
387
388 /**********************************************
389 osl_sendResourcePipe
390 *********************************************/
391
392 sal_Bool osl_sendResourcePipe(oslPipe pPipe, oslSocket pSocket)
393 {
394 sal_Bool bRet = sal_False;
395
396 if ( pSocket == 0 || pPipe == 0 )
397 {
398 return sal_False;
399 }
400
401 bRet = sendFdPipe(pPipe->m_Socket,pSocket->m_Socket);
402
403 return bRet;
404 }
405
406 /**********************************************
407 osl_receiveResourcePipe
408 *********************************************/
409
410 oslSocket osl_receiveResourcePipe(oslPipe pPipe)
411 {
412 oslSocket pSocket=0;
413
414 if ( pPipe == 0 )
415 {
416 return 0;
417 }
418
419 pSocket = receiveFdPipe(pPipe->m_Socket);
420
421 return (oslSocket) pSocket;
422 }
423
424
425
426 /******************************************************************************
427 *
428 * Functions for starting a process
429 *
430 *****************************************************************************/
431
432 static void ChildStatusProc(void *pData)
433 {
434 int i;
435 /* int first = 0;*/
436 pid_t pid;
437 /* int status;*/
438 int channel[2];
439 ProcessData data;
440 ProcessData *pdata;
441 int stdOutput[2] = { -1, -1 }, stdInput[2] = { -1, -1 }, stdError[2] = { -1, -1 };
442
443 pdata = (ProcessData *)pData;
444
445 /* make a copy of our data, because forking will only copy
446 our local stack of the thread, so the process data will not be accessible
447 in our child process */
448 memcpy(&data, pData, sizeof(data));
449
450 socketpair(AF_UNIX, SOCK_STREAM, 0, channel);
451
452 fcntl(channel[0], F_SETFD, FD_CLOEXEC);
453 fcntl(channel[1], F_SETFD, FD_CLOEXEC);
454
455 /* Create redirected IO pipes */
456
457 if ( data.m_pInputWrite )
458 pipe( stdInput );
459
460 if ( data.m_pOutputRead )
461 pipe( stdOutput );
462
463 if ( data.m_pErrorRead )
464 pipe( stdError );
465
466 if ((pid = fork()) == 0)
467 {
468 /* Child */
469 close(channel[0]);
470
471 if ((data.m_uid != (uid_t)-1) && ((data.m_uid != getuid()) || (data.m_gid != getgid())))
472 {
473 OSL_ASSERT(geteuid() == 0); /* must be root */
474
475 if (! INIT_GROUPS(data.m_name, data.m_gid) || (setuid(data.m_uid) != 0))
476 OSL_TRACE("Failed to change uid and guid, errno=%d (%s)\n", errno, strerror(errno));
477 #if defined(LINUX) || defined (FREEBSD)
478 unsetenv("HOME");
479 #else
480 putenv("HOME=");
481 #endif
482 }
483
484 if ((data.m_uid == (uid_t)-1) || ((data.m_uid == getuid()) && (data.m_gid == getgid())))
485
486 {
487 if (data.m_pszDir)
488 chdir(data.m_pszDir);
489
490 for (i = 0; data.m_pszEnv[i] != NULL; i++)
491 putenv(data.m_pszEnv[i]);
492
493 #if defined(LINUX) && !defined(NPTL)
494 /* mfe: linux likes to have just one thread when the exec family is called */
495 /* this np function has this purpose ... */
496 pthread_kill_other_threads_np();
497 #endif
498 OSL_TRACE("ChildStatusProc : starting '%s'",data.m_pszArgs[0]);
499
500 /* Connect std IO to pipe ends */
501
502 /* Write end of stdInput not used in child process */
503 close( stdInput[1] );
504
505 /* Read end of stdOutput not used in child process */
506 close( stdOutput[0] );
507
508 /* Read end of stdError not used in child process */
509 close( stdError[0] );
510
511 /* Redirect pipe ends to std IO */
512
513 if ( stdInput[0] != STDIN_FILENO )
514 {
515 dup2( stdInput[0], STDIN_FILENO );
516 close( stdInput[0] );
517 }
518
519 if ( stdOutput[1] != STDOUT_FILENO )
520 {
521 dup2( stdOutput[1], STDOUT_FILENO );
522 close( stdOutput[1] );
523 }
524
525 if ( stdError[1] != STDERR_FILENO )
526 {
527 dup2( stdError[1], STDERR_FILENO );
528 close( stdError[1] );
529 }
530
531 pid=execv(data.m_pszArgs[0], (sal_Char **)data.m_pszArgs);
532
533 }
534
535 OSL_TRACE("Failed to exec, errno=%d (%s)\n", errno, strerror(errno));
536
537 OSL_TRACE("ChildStatusProc : starting '%s' failed",data.m_pszArgs[0]);
538
539 /* if we reach here, something went wrong */
540 write(channel[1], &errno, sizeof(errno));
541
542 close(channel[1]);
543
544 _exit(255);
545 }
546 else
547 { /* Parent */
548 int status;
549
550 close(channel[1]);
551
552 /* Close unused pipe ends */
553 close( stdInput[0] );
554 close( stdOutput[1] );
555 close( stdError[1] );
556
557 while (((i = read(channel[0], &status, sizeof(status))) < 0))
558 {
559 if (errno != EINTR)
560 break;
561 }
562
563 close(channel[0]);
564
565
566 if ((pid > 0) && (i == 0))
567 {
568 pid_t child_pid;
569 osl_acquireMutex(ChildListMutex);
570
571 pdata->m_pProcImpl->m_pid = pid;
572 pdata->m_pProcImpl->m_pnext = ChildList;
573 ChildList = pdata->m_pProcImpl;
574
575 /* Store used pipe ends in data structure */
576
577 if ( pdata->m_pInputWrite )
578 *(pdata->m_pInputWrite) = osl_createFileHandleFromFD( stdInput[1] );
579
580 if ( pdata->m_pOutputRead )
581 *(pdata->m_pOutputRead) = osl_createFileHandleFromFD( stdOutput[0] );
582
583 if ( pdata->m_pErrorRead )
584 *(pdata->m_pErrorRead) = osl_createFileHandleFromFD( stdError[0] );
585
586 osl_releaseMutex(ChildListMutex);
587
588 osl_setCondition(pdata->m_started);
589
590 do
591 {
592 child_pid = waitpid(pid, &status, 0);
593 } while ( 0 > child_pid && EINTR == errno );
594
595 if ( child_pid < 0)
596 {
597 OSL_TRACE("Failed to wait for child process, errno=%d (%s)\n", errno, strerror(errno));
598
599 /*
600 We got an other error than EINTR. Anyway we have to wake up the
601 waiting thread under any circumstances */
602
603 child_pid = pid;
604 }
605
606
607 if ( child_pid > 0 )
608 {
609 oslProcessImpl* pChild;
610
611 osl_acquireMutex(ChildListMutex);
612
613 pChild = ChildList;
614
615 /* check if it is one of our child processes */
616 while (pChild != NULL)
617 {
618 if (pChild->m_pid == child_pid)
619 {
620 if (WIFEXITED(status))
621 pChild->m_status = WEXITSTATUS(status);
622 else
623 pChild->m_status = -1;
624
625 osl_setCondition(pChild->m_terminated);
626 }
627
628 pChild = pChild->m_pnext;
629 }
630
631 osl_releaseMutex(ChildListMutex);
632 }
633 }
634 else
635 {
636 OSL_TRACE("ChildStatusProc : starting '%s' failed",data.m_pszArgs[0]);
637 OSL_TRACE("Failed to launch child process, child reports errno=%d (%s)\n", status, strerror(status));
638
639 /* Close pipe ends */
640 if ( pdata->m_pInputWrite )
641 *pdata->m_pInputWrite = NULL;
642
643 if ( pdata->m_pOutputRead )
644 *pdata->m_pOutputRead = NULL;
645
646 if ( pdata->m_pErrorRead )
647 *pdata->m_pErrorRead = NULL;
648
649 close( stdInput[1] );
650 close( stdOutput[0] );
651 close( stdError[0] );
652
653 //if pid > 0 then a process was created, even if it later failed
654 //e.g. bash searching for a command to execute, and we still
655 //need to clean it up to avoid "defunct" processes
656 if (pid > 0)
657 {
658 pid_t child_pid;
659 do
660 {
661 child_pid = waitpid(pid, &status, 0);
662 } while ( 0 > child_pid && EINTR == errno );
663 }
664
665 /* notify (and unblock) parent thread */
666 osl_setCondition(pdata->m_started);
667 }
668 }
669 }
670
671 /**********************************************
672 osl_executeProcess_WithRedirectedIO
673 *********************************************/
674
675 oslProcessError SAL_CALL osl_executeProcess_WithRedirectedIO(
676 rtl_uString *ustrImageName,
677 rtl_uString *ustrArguments[],
678 sal_uInt32 nArguments,
679 oslProcessOption Options,
680 oslSecurity Security,
681 rtl_uString *ustrWorkDir,
682 rtl_uString *ustrEnvironment[],
683 sal_uInt32 nEnvironmentVars,
684 oslProcess *pProcess,
685 oslFileHandle *pInputWrite,
686 oslFileHandle *pOutputRead,
687 oslFileHandle *pErrorRead
688 )
689 {
690
691 oslProcessError Error;
692 sal_Char* pszWorkDir=0;
693 sal_Char** pArguments=0;
694 sal_Char** pEnvironment=0;
695 unsigned int idx;
696
697 char szImagePath[PATH_MAX] = "";
698 char szWorkDir[PATH_MAX] = "";
699
700 if ( ustrImageName && ustrImageName->length )
701 {
702 FileURLToPath( szImagePath, PATH_MAX, ustrImageName );
703 }
704
705 if ( ustrWorkDir != 0 && ustrWorkDir->length )
706 {
707 FileURLToPath( szWorkDir, PATH_MAX, ustrWorkDir );
708 pszWorkDir = szWorkDir;
709 }
710
711 if ( pArguments == 0 && nArguments > 0 )
712 {
713 pArguments = (sal_Char**) malloc( ( nArguments + 2 ) * sizeof(sal_Char*) );
714 }
715
716
717 for ( idx = 0 ; idx < nArguments ; ++idx )
718 {
719 rtl_String* strArg =0;
720
721
722 rtl_uString2String( &strArg,
723 rtl_uString_getStr(ustrArguments[idx]),
724 rtl_uString_getLength(ustrArguments[idx]),
725 osl_getThreadTextEncoding(),
726 OUSTRING_TO_OSTRING_CVTFLAGS );
727
728 pArguments[idx]=strdup(rtl_string_getStr(strArg));
729 rtl_string_release(strArg);
730 pArguments[idx+1]=0;
731 }
732
733 for ( idx = 0 ; idx < nEnvironmentVars ; ++idx )
734 {
735 rtl_String* strEnv=0;
736
737 if ( pEnvironment == 0 )
738 {
739 pEnvironment = (sal_Char**) malloc( ( nEnvironmentVars + 2 ) * sizeof(sal_Char*) );
740 }
741
742 rtl_uString2String( &strEnv,
743 rtl_uString_getStr(ustrEnvironment[idx]),
744 rtl_uString_getLength(ustrEnvironment[idx]),
745 osl_getThreadTextEncoding(),
746 OUSTRING_TO_OSTRING_CVTFLAGS );
747
748 pEnvironment[idx]=strdup(rtl_string_getStr(strEnv));
749 rtl_string_release(strEnv);
750 pEnvironment[idx+1]=0;
751 }
752
753
754 Error = osl_psz_executeProcess(szImagePath,
755 pArguments,
756 Options,
757 Security,
758 pszWorkDir,
759 pEnvironment,
760 pProcess,
761 pInputWrite,
762 pOutputRead,
763 pErrorRead
764 );
765
766 if ( pArguments != 0 )
767 {
768 for ( idx = 0 ; idx < nArguments ; ++idx )
769 {
770 if ( pArguments[idx] != 0 )
771 {
772 free(pArguments[idx]);
773 }
774 }
775 free(pArguments);
776 }
777
778 if ( pEnvironment != 0 )
779 {
780 for ( idx = 0 ; idx < nEnvironmentVars ; ++idx )
781 {
782 if ( pEnvironment[idx] != 0 )
783 {
784 free(pEnvironment[idx]);
785 }
786 }
787 free(pEnvironment);
788 }
789
790 return Error;
791 }
792
793 /**********************************************
794 osl_executeProcess
795 *********************************************/
796
797 oslProcessError SAL_CALL osl_executeProcess(
798 rtl_uString *ustrImageName,
799 rtl_uString *ustrArguments[],
800 sal_uInt32 nArguments,
801 oslProcessOption Options,
802 oslSecurity Security,
803 rtl_uString *ustrWorkDir,
804 rtl_uString *ustrEnvironment[],
805 sal_uInt32 nEnvironmentVars,
806 oslProcess *pProcess
807 )
808 {
809 return osl_executeProcess_WithRedirectedIO(
810 ustrImageName,
811 ustrArguments,
812 nArguments,
813 Options,
814 Security,
815 ustrWorkDir,
816 ustrEnvironment,
817 nEnvironmentVars,
818 pProcess,
819 NULL,
820 NULL,
821 NULL
822 );
823 }
824
825 /**********************************************
826 osl_psz_executeProcess
827 *********************************************/
828
829 oslProcessError SAL_CALL osl_psz_executeProcess(sal_Char *pszImageName,
830 sal_Char *pszArguments[],
831 oslProcessOption Options,
832 oslSecurity Security,
833 sal_Char *pszDirectory,
834 sal_Char *pszEnvironments[],
835 oslProcess *pProcess,
836 oslFileHandle *pInputWrite,
837 oslFileHandle *pOutputRead,
838 oslFileHandle *pErrorRead
839 )
840 {
841 int i;
842 sal_Char path[PATH_MAX + 1];
843 ProcessData Data;
844 oslThread hThread;
845
846 path[0] = '\0';
847
848 memset(&Data,0,sizeof(ProcessData));
849 Data.m_pInputWrite = pInputWrite;
850 Data.m_pOutputRead = pOutputRead;
851 Data.m_pErrorRead = pErrorRead;
852
853 if (pszImageName == NULL)
854 pszImageName = pszArguments[0];
855
856 OSL_ASSERT(pszImageName != NULL);
857
858 if ( pszImageName == 0 )
859 {
860 return osl_Process_E_NotFound;
861 }
862
863 if ((Options & osl_Process_SEARCHPATH) &&
864 (osl_searchPath_impl(pszImageName, NULL, '\0', path, sizeof(path)) == osl_Process_E_None))
865 pszImageName = path;
866
867 Data.m_pszArgs[0] = strdup(pszImageName);
868 Data.m_pszArgs[1] = 0;
869
870 if ( pszArguments != 0 )
871 {
872 for (i = 0; ((i + 2) < MAX_ARGS) && (pszArguments[i] != NULL); i++)
873 Data.m_pszArgs[i+1] = strdup(pszArguments[i]);
874 Data.m_pszArgs[i+2] = NULL;
875 }
876
877 Data.m_options = Options;
878 Data.m_pszDir = (pszDirectory != NULL) ? strdup(pszDirectory) : NULL;
879
880 if (pszEnvironments != NULL)
881 {
882 for (i = 0; ((i + 1) < MAX_ENVS) && (pszEnvironments[i] != NULL); i++)
883 Data.m_pszEnv[i] = strdup(pszEnvironments[i]);
884 Data.m_pszEnv[i+1] = NULL;
885 }
886 else
887 Data.m_pszEnv[0] = NULL;
888
889 if (Security != NULL)
890 {
891 Data.m_uid = ((oslSecurityImpl*)Security)->m_pPasswd.pw_uid;
892 Data.m_gid = ((oslSecurityImpl*)Security)->m_pPasswd.pw_gid;
893 Data.m_name = ((oslSecurityImpl*)Security)->m_pPasswd.pw_name;
894 }
895 else
896 Data.m_uid = (uid_t)-1;
897
898 Data.m_pProcImpl = (oslProcessImpl*) malloc(sizeof(oslProcessImpl));
899 Data.m_pProcImpl->m_pid = 0;
900 Data.m_pProcImpl->m_terminated = osl_createCondition();
901 Data.m_pProcImpl->m_pnext = NULL;
902
903 if (ChildListMutex == NULL)
904 ChildListMutex = osl_createMutex();
905
906 Data.m_started = osl_createCondition();
907
908 hThread = osl_createThread(ChildStatusProc, &Data);
909
910 osl_waitCondition(Data.m_started, NULL);
911 osl_destroyCondition(Data.m_started);
912
913 for (i = 0; Data.m_pszArgs[i] != NULL; i++)
914 free((void *)Data.m_pszArgs[i]);
915
916 for (i = 0; Data.m_pszEnv[i] != NULL; i++)
917 free((void *)Data.m_pszEnv[i]);
918
919 if ( Data.m_pszDir != 0 )
920 {
921 free((void *)Data.m_pszDir);
922 }
923
924 osl_destroyThread(hThread);
925
926 if (Data.m_pProcImpl->m_pid != 0)
927 {
928 *pProcess = Data.m_pProcImpl;
929
930 if (Options & osl_Process_WAIT)
931 osl_joinProcess(*pProcess);
932
933 return osl_Process_E_None;
934 }
935
936 osl_destroyCondition(Data.m_pProcImpl->m_terminated);
937 free(Data.m_pProcImpl);
938
939 return osl_Process_E_Unknown;
940 }
941
942
943 /******************************************************************************
944 *
945 * Functions for processes
946 *
947 *****************************************************************************/
948
949
950 /**********************************************
951 osl_terminateProcess
952 *********************************************/
953
954 oslProcessError SAL_CALL osl_terminateProcess(oslProcess Process)
955 {
956 if (Process == NULL)
957 return osl_Process_E_Unknown;
958
959 if (kill(((oslProcessImpl*)Process)->m_pid, SIGKILL) != 0)
960 {
961 switch (errno)
962 {
963 case EPERM:
964 return osl_Process_E_NoPermission;
965
966 case ESRCH:
967 return osl_Process_E_NotFound;
968
969 default:
970 return osl_Process_E_Unknown;
971 }
972 }
973
974 return osl_Process_E_None;
975 }
976
977 /**********************************************
978 osl_getProcess
979 *********************************************/
980
981 oslProcess SAL_CALL osl_getProcess(oslProcessIdentifier Ident)
982 {
983 oslProcessImpl *pProcImpl;
984
985 if (kill(Ident, 0) != -1)
986 {
987 oslProcessImpl* pChild;
988
989 if (ChildListMutex == NULL)
990 ChildListMutex = osl_createMutex();
991
992 osl_acquireMutex(ChildListMutex);
993
994 pChild = ChildList;
995
996 /* check if it is one of our child processes */
997 while (pChild != NULL)
998 {
999 if (Ident == (sal_uInt32) pChild->m_pid)
1000 break;
1001
1002 pChild = pChild->m_pnext;
1003 }
1004
1005 pProcImpl = (oslProcessImpl*) malloc(sizeof(oslProcessImpl));
1006 pProcImpl->m_pid = Ident;
1007 pProcImpl->m_terminated = osl_createCondition();
1008
1009 if (pChild != NULL)
1010 {
1011 /* process is a child so insert into list */
1012 pProcImpl->m_pnext = pChild->m_pnext;
1013 pChild->m_pnext = pProcImpl;
1014
1015 pProcImpl->m_status = pChild->m_status;
1016
1017 if (osl_checkCondition(pChild->m_terminated))
1018 osl_setCondition(pProcImpl->m_terminated);
1019 }
1020 else
1021 pProcImpl->m_pnext = NULL;
1022
1023 osl_releaseMutex(ChildListMutex);
1024 }
1025 else
1026 pProcImpl = NULL;
1027
1028 return (pProcImpl);
1029 }
1030
1031 /**********************************************
1032 osl_freeProcessHandle
1033 *********************************************/
1034
1035 void SAL_CALL osl_freeProcessHandle(oslProcess Process)
1036 {
1037 if (Process != NULL)
1038 {
1039 oslProcessImpl *pChild, *pPrev = NULL;
1040
1041 OSL_ASSERT(ChildListMutex != NULL);
1042
1043 if ( ChildListMutex == 0 )
1044 {
1045 return;
1046 }
1047
1048 osl_acquireMutex(ChildListMutex);
1049
1050 pChild = ChildList;
1051
1052 /* remove process from child list */
1053 while (pChild != NULL)
1054 {
1055 if (pChild == (oslProcessImpl*)Process)
1056 {
1057 if (pPrev != NULL)
1058 pPrev->m_pnext = pChild->m_pnext;
1059 else
1060 ChildList = pChild->m_pnext;
1061
1062 break;
1063 }
1064
1065 pPrev = pChild;
1066 pChild = pChild->m_pnext;
1067 }
1068
1069 osl_releaseMutex(ChildListMutex);
1070
1071 osl_destroyCondition(((oslProcessImpl*)Process)->m_terminated);
1072
1073 free(Process);
1074 }
1075 }
1076
1077 #if defined(LINUX)
1078 struct osl_procStat
1079 {
1080 /* from 'stat' */
1081 pid_t pid; /* pid */
1082 char command[16]; /* 'argv[0]' */ /* mfe: it all right char comm[16] in kernel! */
1083 char state; /* state (running, stopped, ...) */
1084 pid_t ppid; /* parent pid */
1085 pid_t pgrp; /* parent group */
1086 int session; /* session ID */
1087 int tty; /* no of tty */
1088 pid_t tpgid; /* group of process owning the tty */
1089 unsigned long flags; /* flags dunno */
1090 unsigned long minflt; /* minor page faults */
1091 unsigned long cminflt; /* minor page faults with children */
1092 unsigned long majflt; /* major page faults */
1093 unsigned long cmajflt; /* major page faults with children */
1094 unsigned long utime; /* no of jiffies in user mode */
1095 unsigned long stime; /* no of jiffies in kernel mode */
1096 unsigned long cutime; /* no of jiffies in user mode with children */
1097 unsigned long cstime; /* no of jiffies in kernel mode with children */
1098 unsigned long priority; /* nice value + 15 (kernel scheduling prio)*/
1099 long nice; /* nice value */
1100 long timeout; /* no of jiffies of next process timeout */
1101 long itrealvalue; /* no jiffies before next SIGALRM */
1102 unsigned long starttime; /* process started this no of jiffies after boot */
1103 unsigned long vsize; /* virtual memory size (in bytes) */
1104 long rss; /* resident set size (in pages) */
1105 unsigned long rss_rlim; /* rss limit (in bytes) */
1106 unsigned long startcode; /* address above program text can run */
1107 unsigned long endcode; /* address below program text can run */
1108 unsigned long startstack; /* address of start of stack */
1109 unsigned long kstkesp; /* current value of 'esp' (stack pointer) */
1110 unsigned long kstkeip; /* current value of 'eip' (instruction pointer) */
1111 /* mfe: Linux > 2.1.7x have more signals (88) */
1112 /*#ifdef LINUX */
1113 char signal[24]; /* pending signals */
1114 char blocked[24]; /* blocked signals */
1115 char sigignore[24]; /* ignored signals */
1116 char sigcatch[24]; /* catched signals */
1117 /*#else*/
1118 /* long long signal;*/
1119 /* long long blocked;*/
1120 /* long long sigignore;*/
1121 /* long long sigcatch;*/
1122 /*#endif */
1123 unsigned long wchan; /* 'channel' the process is waiting in */
1124 unsigned long nswap; /* ? */
1125 unsigned long cnswap; /* ? */
1126
1127 /* from 'statm' */
1128 long size; /* numbers of pages in memory */
1129 long resident; /* number of resident pages */
1130 long share; /* number of shared pages */
1131 long trs; /* text resident size */
1132 long lrs; /* library resident size */
1133 long drs; /* data resident size */
1134 long dt; /* ditry pages */
1135
1136 /* from 'status' */
1137 int ruid; /* real uid */
1138 int euid; /* effective uid */
1139 int suid; /* saved uid */
1140 int fuid; /* file access uid */
1141 int rgid; /* real gid */
1142 int egid; /* effective gid */
1143 int sgid; /* saved gid */
1144 int fgid; /* file access gid */
1145 unsigned long vm_size; /* like vsize but on kb */
1146 unsigned long vm_lock; /* locked pages in kb */
1147 unsigned long vm_rss; /* like rss but in kb */
1148 unsigned long vm_data; /* data size */
1149 unsigned long vm_stack; /* stack size */
1150 unsigned long vm_exe; /* executable size */
1151 unsigned long vm_lib; /* library size */
1152 };
1153
1154 /**********************************************
1155 osl_getProcStat
1156 *********************************************/
1157
1158 void osl_getProcStat(pid_t pid, struct osl_procStat* procstat)
1159 {
1160 int fd = 0;
1161 char name[PATH_MAX + 1];
1162 snprintf(name, sizeof(name), "/proc/%u/stat", pid);
1163
1164 if ((fd = open(name,O_RDONLY)) >=0 )
1165 {
1166 char* tmp=0;
1167 char prstatbuf[512];
1168 memset(prstatbuf,0,512);
1169 read(fd,prstatbuf,511);
1170
1171 close(fd);
1172 /*printf("%s\n\n",prstatbuf);*/
1173
1174
1175 tmp = strrchr(prstatbuf, ')');
1176 *tmp = '\0';
1177 memset(procstat->command, 0, sizeof(procstat->command));
1178
1179 sscanf(prstatbuf, "%d (%15c", &procstat->pid, procstat->command);
1180 sscanf(tmp + 2,
1181 "%c"
1182 "%i %i %i %i %i"
1183 "%lu %lu %lu %lu %lu"
1184 "%lu %lu %lu %lu"
1185 "%lu %li %li %li"
1186 "%lu %lu %li %lu"
1187 "%lu %lu %lu %lu %lu"
1188 "%s %s %s %s"
1189 "%lu %lu %lu",
1190 &procstat->state,
1191 &procstat->ppid, &procstat->pgrp, &procstat->session, &procstat->tty, &procstat->tpgid,
1192 &procstat->flags, &procstat->minflt, &procstat->cminflt, &procstat->majflt, &procstat->cmajflt,
1193 &procstat->utime, &procstat->stime, &procstat->cutime, &procstat->cstime,
1194 &procstat->priority, &procstat->nice, &procstat->timeout, &procstat->itrealvalue,
1195 &procstat->starttime, &procstat->vsize, &procstat->rss, &procstat->rss_rlim,
1196 &procstat->startcode, &procstat->endcode, &procstat->startstack, &procstat->kstkesp, &procstat->kstkeip,
1197 procstat->signal, procstat->blocked, procstat->sigignore, procstat->sigcatch,
1198 &procstat->wchan, &procstat->nswap, &procstat->cnswap
1199 );
1200 }
1201 }
1202
1203 /**********************************************
1204 osl_getProcStatm
1205 *********************************************/
1206
1207 void osl_getProcStatm(pid_t pid, struct osl_procStat* procstat)
1208 {
1209 int fd = 0;
1210 char name[PATH_MAX + 1];
1211 snprintf(name, sizeof(name), "/proc/%u/statm", pid);
1212
1213 if ((fd = open(name,O_RDONLY)) >=0 )
1214 {
1215 char prstatmbuf[512];
1216 memset(prstatmbuf,0,512);
1217 read(fd,prstatmbuf,511);
1218
1219 close(fd);
1220
1221 /* printf("\n\n%s\n\n",prstatmbuf);*/
1222
1223 sscanf(prstatmbuf,"%li %li %li %li %li %li %li",
1224 &procstat->size, &procstat->resident, &procstat->share,
1225 &procstat->trs, &procstat->lrs, &procstat->drs,
1226 &procstat->dt
1227 );
1228 }
1229 }
1230
1231 /**********************************************
1232 osl_getProcStatus
1233 *********************************************/
1234
1235 void osl_getProcStatus(pid_t pid, struct osl_procStat* procstat)
1236 {
1237 int fd = 0;
1238 char name[PATH_MAX + 1];
1239 snprintf(name, sizeof(name), "/proc/%u/status", pid);
1240
1241 if ((fd = open(name,O_RDONLY)) >=0 )
1242 {
1243 char* tmp=0;
1244 char prstatusbuf[512];
1245 memset(prstatusbuf,0,512);
1246 read(fd,prstatusbuf,511);
1247
1248 close(fd);
1249
1250 /* printf("\n\n%s\n\n",prstatusbuf);*/
1251
1252 tmp = strstr(prstatusbuf,"Uid:");
1253 if(tmp)
1254 {
1255 sscanf(tmp,"Uid:\t%d\t%d\t%d\t%d",
1256 &procstat->ruid, &procstat->euid, &procstat->suid, &procstat->fuid
1257 );
1258 }
1259
1260
1261 tmp = strstr(prstatusbuf,"Gid:");
1262 if(tmp)
1263 {
1264 sscanf(tmp,"Gid:\t%d\t%d\t%d\t%d",
1265 &procstat->rgid, &procstat->egid, &procstat->sgid, &procstat->fgid
1266 );
1267 }
1268
1269 tmp = strstr(prstatusbuf,"VmSize:");
1270 if(tmp)
1271 {
1272 sscanf(tmp,
1273 "VmSize: %lu kB\n"
1274 "VmLck: %lu kB\n"
1275 "VmRSS: %lu kB\n"
1276 "VmData: %lu kB\n"
1277 "VmStk: %lu kB\n"
1278 "VmExe: %lu kB\n"
1279 "VmLib: %lu kB\n",
1280 &procstat->vm_size, &procstat->vm_lock, &procstat->vm_rss, &procstat->vm_data,
1281 &procstat->vm_stack, &procstat->vm_exe, &procstat->vm_lib
1282 );
1283 }
1284
1285 tmp = strstr(prstatusbuf,"SigPnd:");
1286 if(tmp)
1287 {
1288 sscanf(tmp, "SigPnd: %s SigBlk: %s SigIgn: %s %*s %s",
1289 procstat->signal, procstat->blocked, procstat->sigignore, procstat->sigcatch
1290 );
1291 }
1292 }
1293 }
1294
1295 #endif
1296
1297 /**********************************************
1298 osl_getProcessInfo
1299 *********************************************/
1300
1301 oslProcessError SAL_CALL osl_getProcessInfo(oslProcess Process, oslProcessData Fields, oslProcessInfo* pInfo)
1302 {
1303 pid_t pid;
1304
1305 if (Process == NULL)
1306 pid = getpid();
1307 else
1308 pid = ((oslProcessImpl*)Process)->m_pid;
1309
1310 if (! pInfo || (pInfo->Size != sizeof(oslProcessInfo)))
1311 return osl_Process_E_Unknown;
1312
1313 pInfo->Fields = 0;
1314
1315 if (Fields & osl_Process_IDENTIFIER)
1316 {
1317 pInfo->Ident = pid;
1318 pInfo->Fields |= osl_Process_IDENTIFIER;
1319 }
1320
1321 if (Fields & osl_Process_EXITCODE)
1322 {
1323 if ((Process != NULL) &&
1324 osl_checkCondition(((oslProcessImpl*)Process)->m_terminated))
1325 {
1326 pInfo->Code = ((oslProcessImpl*)Process)->m_status;
1327 pInfo->Fields |= osl_Process_EXITCODE;
1328 }
1329 }
1330
1331 if (Fields & (osl_Process_HEAPUSAGE | osl_Process_CPUTIMES))
1332 {
1333
1334 #if defined(SOLARIS)
1335
1336 int fd;
1337 sal_Char name[PATH_MAX + 1];
1338
1339 snprintf(name, sizeof(name), "/proc/%u", pid);
1340
1341 if ((fd = open(name, O_RDONLY)) >= 0)
1342 {
1343 prstatus_t prstatus;
1344
1345 if (ioctl(fd, PIOCSTATUS, &prstatus) >= 0)
1346 {
1347 if (Fields & osl_Process_CPUTIMES)
1348 {
1349 pInfo->UserTime.Seconds = prstatus.pr_utime.tv_sec;
1350 pInfo->UserTime.Nanosec = prstatus.pr_utime.tv_nsec;
1351 pInfo->SystemTime.Seconds = prstatus.pr_stime.tv_sec;
1352 pInfo->SystemTime.Nanosec = prstatus.pr_stime.tv_nsec;
1353
1354 pInfo->Fields |= osl_Process_CPUTIMES;
1355 }
1356
1357 if (Fields & osl_Process_HEAPUSAGE)
1358 {
1359 pInfo->HeapUsage = prstatus.pr_brksize;
1360
1361 pInfo->Fields |= osl_Process_HEAPUSAGE;
1362 }
1363
1364 close(fd);
1365
1366 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1367 }
1368 else
1369 close(fd);
1370 }
1371
1372 #elif defined(HPUX)
1373
1374 struct pst_status prstatus;
1375
1376 if (pstat_getproc(&prstatus, sizeof(prstatus), (size_t)0, pid) == 1)
1377 {
1378 if (Fields & osl_Process_CPUTIMES)
1379 {
1380 pInfo->UserTime.Seconds = prstatus.pst_utime;
1381 pInfo->UserTime.Nanosec = 500000L;
1382 pInfo->SystemTime.Seconds = prstatus.pst_stime;
1383 pInfo->SystemTime.Nanosec = 500000L;
1384
1385 pInfo->Fields |= osl_Process_CPUTIMES;
1386 }
1387
1388 if (Fields & osl_Process_HEAPUSAGE)
1389 {
1390 pInfo->HeapUsage = prstatus.pst_vdsize*PAGESIZE;
1391
1392 pInfo->Fields |= osl_Process_HEAPUSAGE;
1393 }
1394
1395 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1396 }
1397
1398 #elif defined(IRIX)
1399
1400 int fd;
1401 sal_Char name[PATH_MAX + 1];
1402
1403 snprintf(name, sizeof(name), "/proc/%u", pid);
1404
1405 if ((fd = open(name, O_RDONLY)) >= 0)
1406 {
1407 prstatus_t prstatus;
1408 prpsinfo_t prpsinfo;
1409
1410 if (ioctl(fd, PIOCSTATUS, &prstatus) >= 0 &&
1411 ioctl(fd, PIOCPSINFO, &prpsinfo) >= 0)
1412 {
1413 if (Fields & osl_Process_CPUTIMES)
1414 {
1415 pInfo->UserTime.Seconds = prstatus.pr_utime.tv_sec;
1416 pInfo->UserTime.Nanosec = prstatus.pr_utime.tv_nsec;
1417 pInfo->SystemTime.Seconds = prstatus.pr_stime.tv_sec;
1418 pInfo->SystemTime.Nanosec = prstatus.pr_stime.tv_nsec;
1419
1420 pInfo->Fields |= osl_Process_CPUTIMES;
1421 }
1422
1423 if (Fields & osl_Process_HEAPUSAGE)
1424 {
1425 int pagesize = getpagesize();
1426
1427 pInfo->HeapUsage = prpsinfo.pr_size*pagesize;
1428
1429 pInfo->Fields |= osl_Process_HEAPUSAGE;
1430 }
1431
1432 close(fd);
1433
1434 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1435 }
1436 else
1437 close(fd);
1438 }
1439
1440 #elif defined(LINUX)
1441
1442 /* int fd = 0;*/
1443 struct osl_procStat procstat;
1444 memset(&procstat,0,sizeof(procstat));
1445
1446 osl_getProcStat(pid, &procstat);
1447 osl_getProcStatm(pid, &procstat);
1448 osl_getProcStatus(pid, &procstat);
1449
1450 if ( Fields & osl_Process_CPUTIMES)
1451 {
1452 /*
1453 * mfe:
1454 * We calculate only time of the process proper.
1455 * Threads are processes, we do not consider their time here!
1456 * (For this, cutime and cstime should be used, it seems not
1457 * to work in 2.0.36)
1458 */
1459
1460 long clktck;
1461 unsigned long hz;
1462 unsigned long userseconds;
1463 unsigned long systemseconds;
1464
1465 clktck = sysconf(_SC_CLK_TCK);
1466 if (clktck < 0) {
1467 return osl_Process_E_Unknown;
1468 }
1469 hz = (unsigned long) clktck;
1470
1471 userseconds = procstat.utime/hz;
1472 systemseconds = procstat.stime/hz;
1473
1474 pInfo->UserTime.Seconds = userseconds;
1475 pInfo->UserTime.Nanosec = procstat.utime - (userseconds * hz);
1476 pInfo->SystemTime.Seconds = systemseconds;
1477 pInfo->SystemTime.Nanosec = procstat.stime - (systemseconds * hz);
1478
1479 pInfo->Fields |= osl_Process_CPUTIMES;
1480 }
1481
1482 if (Fields & osl_Process_HEAPUSAGE)
1483 {
1484 /*
1485 * mfe:
1486 * vm_data (found in status) shows the size of the data segment
1487 * it a rough approximation of the core heap size
1488 */
1489 pInfo->HeapUsage = procstat.vm_data*1024;
1490
1491 pInfo->Fields |= osl_Process_HEAPUSAGE;
1492 }
1493
1494 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1495 #endif
1496
1497 }
1498
1499 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1500 }
1501
1502
1503 /***********************************************
1504 helper function for osl_joinProcessWithTimeout
1505 **********************************************/
1506
1507 static int is_timeout(const struct timeval* tend)
1508 {
1509 struct timeval tcurrent;
1510 gettimeofday(&tcurrent, NULL);
1511 return (tcurrent.tv_sec >= tend->tv_sec);
1512 }
1513
1514 /**********************************************
1515 kill(pid, 0) is usefull for checking if a
1516 process is still alive, but remember that
1517 kill even returns 0 if the process is already
1518 a zombie.
1519 *********************************************/
1520
1521 static int is_process_dead(pid_t pid)
1522 {
1523 return ((-1 == kill(pid, 0)) && (ESRCH == errno));
1524 }
1525
1526 /**********************************************
1527 osl_joinProcessWithTimeout
1528 *********************************************/
1529
1530 oslProcessError SAL_CALL osl_joinProcessWithTimeout(oslProcess Process, const TimeValue* pTimeout)
1531 {
1532 oslProcessImpl* pChild = ChildList;
1533 oslProcessError osl_error = osl_Process_E_None;
1534
1535 OSL_PRECOND(Process, "osl_joinProcess: Invalid parameter");
1536 OSL_ASSERT(ChildListMutex);
1537
1538 if (NULL == Process || 0 == ChildListMutex)
1539 return osl_Process_E_Unknown;
1540
1541 osl_acquireMutex(ChildListMutex);
1542
1543 /* check if process is a child of ours */
1544 while (pChild != NULL)
1545 {
1546 if (pChild == (oslProcessImpl*)Process)
1547 break;
1548
1549 pChild = pChild->m_pnext;
1550 }
1551
1552 osl_releaseMutex(ChildListMutex);
1553
1554 if (pChild != NULL)
1555 {
1556 oslConditionResult cond_res = osl_waitCondition(pChild->m_terminated, pTimeout);
1557
1558 if (osl_cond_result_timeout == cond_res)
1559 osl_error = osl_Process_E_TimedOut;
1560 else if (osl_cond_result_ok != cond_res)
1561 osl_error = osl_Process_E_Unknown;
1562 }
1563 else /* alien process; StatusThread will not be able
1564 to set the condition terminated */
1565 {
1566 pid_t pid = ((oslProcessImpl*)Process)->m_pid;
1567
1568 if (pTimeout)
1569 {
1570 int timeout = 0;
1571 struct timeval tend;
1572
1573 gettimeofday(&tend, NULL);
1574
1575 tend.tv_sec += pTimeout->Seconds;
1576
1577 while (!is_process_dead(pid) && ((timeout = is_timeout(&tend)) == 0))
1578 sleep(1);
1579
1580 if (timeout)
1581 osl_error = osl_Process_E_TimedOut;
1582 }
1583 else /* infinite */
1584 {
1585 while (!is_process_dead(pid))
1586 sleep(1);
1587 }
1588 }
1589 return osl_error;
1590 }
1591
1592 /**********************************************
1593 osl_joinProcess
1594 *********************************************/
1595
1596 oslProcessError SAL_CALL osl_joinProcess(oslProcess Process)
1597 {
1598 return osl_joinProcessWithTimeout(Process, NULL);
1599 }
vba interoperability for OOo