more arm, waidpid fixes
[oweals/gnunet.git] / src / util / os_priority.c
1 /*
2      This file is part of GNUnet
3      (C) 2002, 2003, 2004, 2005, 2006 Christian Grothoff (and other contributing authors)
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 2, or (at your
8      option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18      Boston, MA 02111-1307, USA.
19 */
20
21 /**
22  * @file util/os/priority.c
23  * @brief Methods to set process priority
24  * @author Nils Durner
25  */
26
27 #include "platform.h"
28 #include "gnunet_common.h"
29 #include "gnunet_os_lib.h"
30
31 /**
32  * Set our process priority
33  */
34 int
35 GNUNET_OS_set_process_priority (pid_t proc,
36                                 enum GNUNET_SCHEDULER_Priority eprio)
37 {
38   int prio = 0;
39
40   GNUNET_assert (eprio < GNUNET_SCHEDULER_PRIORITY_COUNT);
41   if (eprio == GNUNET_SCHEDULER_PRIORITY_KEEP)
42     return GNUNET_OK;
43   /* convert to MINGW/Unix values */
44   switch (eprio)
45     {
46     case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
47 #ifdef MINGW
48       prio = NORMAL_PRIORITY_CLASS;
49 #else
50       prio = 0;
51 #endif
52       break;
53     case GNUNET_SCHEDULER_PRIORITY_HIGH:
54 #ifdef MINGW
55       prio = ABOVE_NORMAL_PRIORITY_CLASS;
56 #else
57       prio = -5;
58 #endif
59       break;
60     case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
61 #ifdef MINGW
62       prio = BELOW_NORMAL_PRIORITY_CLASS;
63 #else
64       prio = 10;
65 #endif
66       break;
67     case GNUNET_SCHEDULER_PRIORITY_UI:
68     case GNUNET_SCHEDULER_PRIORITY_URGENT:
69 #ifdef MINGW
70       prio = HIGH_PRIORITY_CLASS;
71 #else
72       prio = -10;
73 #endif
74       break;
75     case GNUNET_SCHEDULER_PRIORITY_IDLE:
76 #ifdef MINGW
77       prio = IDLE_PRIORITY_CLASS;
78 #else
79       prio = 19;
80 #endif
81       break;
82     default:
83       GNUNET_assert (0);
84       return GNUNET_SYSERR;
85     }
86   /* Set process priority */
87 #ifdef MINGW
88   SetPriorityClass (GetCurrentProcess (), prio);
89 #else
90   if (proc == getpid ())
91     {
92       errno = 0;
93       if ((-1 == nice (prio)) && (errno != 0))
94         {
95           GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
96                                GNUNET_ERROR_TYPE_BULK, "nice");
97           return GNUNET_SYSERR;
98         }
99     }
100   else
101     {
102       if (0 != setpriority (PRIO_PROCESS, proc, prio))
103
104         {
105           GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
106                                GNUNET_ERROR_TYPE_BULK, "setpriority");
107           return GNUNET_SYSERR;
108         }
109     }
110 #endif
111   return GNUNET_OK;
112 }
113
114
115
116 /**
117  * Start a process.
118  *
119  * @param filename name of the binary
120  * @param ... NULL-terminated list of arguments to the process
121  * @return process ID of the new process, -1 on error
122  */
123 pid_t
124 GNUNET_OS_start_process (const char *filename, ...)
125 {
126   va_list ap;
127
128 #ifndef MINGW
129   pid_t ret;
130   char **argv;
131   int argc;
132
133   ret = fork ();
134   if (ret != 0)
135     {
136       if (ret == -1)
137         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
138       return ret;
139     }
140   argc = 0;
141   va_start (ap, filename);
142   while (NULL != va_arg (ap, char *))
143       argc++;
144   va_end (ap);
145   argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
146   argc = 0;
147   va_start (ap, filename);
148   while (NULL != (argv[argc] = va_arg (ap, char *)))
149       argc++;
150   va_end (ap);
151   execvp (filename, argv);
152   GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
153   exit (1);
154 #else
155   char *arg;
156   unsigned int cmdlen;
157   char *cmd, *idx;
158   STARTUPINFO start;
159   PROCESS_INFORMATION proc;
160
161   cmdlen = 0;
162   va_start (ap, filename);
163   while (NULL != (arg = va_arg (ap, char *)))
164     cmdlen = cmdlen + strlen (arg) + 3;
165   va_end (ap);
166
167   cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
168   va_start (ap, filename);
169   while (NULL != (arg = va_arg (ap, char *)))
170     idx += sprintf (idx, "\"%s\" ", arg);
171   va_end (ap);
172
173   memset (&start, 0, sizeof(start));
174   start.cb = sizeof(start);
175
176   if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
177       NULL, &start, &proc))
178   {
179     SetErrnoFromWinError (GetLastError ());
180     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
181     return -1;
182   }
183   CloseHandle (proc.hProcess);
184   CloseHandle (proc.hThread);
185
186   GNUNET_free(cmd);
187
188   return proc.dwProcessId;
189 #endif
190 }
191
192
193
194
195 /**
196  * Start a process.
197  *
198  * @param filename name of the binary
199  * @param argv NULL-terminated list of arguments to the process
200  * @return process ID of the new process, -1 on error
201  */
202 pid_t
203 GNUNET_OS_start_process_v (const char *filename, char *const argv[])
204 {
205 #ifndef MINGW
206   pid_t ret;
207
208   ret = fork ();
209   if (ret != 0)
210     {
211       if (ret == -1)
212         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
213       return ret;
214     }
215   execvp (filename, argv);
216   GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
217   exit (1);
218 #else
219   char **arg;
220   unsigned int cmdlen;
221   char *cmd, *idx;
222   STARTUPINFO start;
223   PROCESS_INFORMATION proc;
224
225   cmdlen = 0;
226   arg = argv;
227   while (*arg)
228   {
229     cmdlen = cmdlen + strlen (*arg) + 3;
230     arg++;
231   }
232
233   cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
234   arg = argv;
235   while (*arg)
236   {
237     idx += sprintf (idx, "\"%s\" ", *arg);
238     arg++;
239   }
240
241   memset (&start, 0, sizeof(start));
242   start.cb = sizeof(start);
243
244   if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
245       NULL, &start, &proc))
246   {
247     SetErrnoFromWinError (GetLastError ());
248     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
249     return -1;
250   }
251   CloseHandle (proc.hProcess);
252   CloseHandle (proc.hThread);
253
254   GNUNET_free(cmd);
255
256   return proc.dwProcessId;
257 #endif
258 }
259
260 /**
261  * Retrieve the status of a process
262  * @param proc process ID
263  * @param type status type
264  * @param code return code/signal number
265  * @return GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise
266  */
267 int
268 GNUNET_OS_process_status (pid_t proc, enum GNUNET_OS_ProcessStatusType *type,
269     unsigned long *code)
270 {
271 #ifndef MINGW
272   int status;
273   int ret;
274
275   GNUNET_assert (0 != proc);
276   ret = waitpid (proc, &status, WNOHANG);
277   if (0 == ret) 
278     {
279       *type = GNUNET_OS_PROCESS_RUNNING;
280       *code = 0;
281       return GNUNET_NO;
282     }
283   if (proc != ret)
284     {
285       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
286       return GNUNET_SYSERR;
287     }
288   if (WIFEXITED (status))
289   {
290     *type = GNUNET_OS_PROCESS_EXITED;
291     *code = WEXITSTATUS (status);
292   }
293   else if (WIFSIGNALED (status))
294   {
295     *type = GNUNET_OS_PROCESS_SIGNALED;
296     *code = WTERMSIG (status);
297   }
298   else if (WIFSTOPPED (status))
299   {
300     *type = GNUNET_OS_PROCESS_SIGNALED;
301     *code = WSTOPSIG (status);
302   }
303   else if (WIFCONTINUED (status))
304   {
305     *type = GNUNET_OS_PROCESS_RUNNING;
306     *code = 0;
307   }
308   else
309   {
310     *type = GNUNET_OS_PROCESS_UNKNOWN;
311     *code = 0;
312   }
313 #else
314   HANDLE h;
315   DWORD c;
316
317   h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
318   if (INVALID_HANDLE_VALUE == h)
319   {
320     SetErrnoFromWinError (GetLastError ());
321     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "OpenProcess");
322     return GNUNET_SYSERR;
323   }
324
325   c = GetExitCodeProcess (proc, &c);
326   if (STILL_ACTIVE == c)
327   {
328     *type = GNUNET_OS_PROCESS_RUNNING;
329     *code = 0;
330     CloseHandle (h);
331     return GNUNET_NO;
332   }
333   *type = GNUNET_OS_PROCESS_EXITED;
334   *code = c;
335   CloseHandle (h);
336 #endif
337
338   return GNUNET_OK;
339 }
340
341 /**
342  * Wait for a process
343  * @param proc process ID to wait for
344  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
345  */
346 int
347 GNUNET_OS_process_wait (pid_t proc)
348 {
349 #ifndef MINGW
350   if (proc != waitpid (proc, NULL, 0))
351     return GNUNET_SYSERR;
352
353   return GNUNET_OK;
354 #else
355   HANDLE h;
356   DWORD c;
357   int ret;
358
359   h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
360   if (INVALID_HANDLE_VALUE == h)
361   {
362     SetErrnoFromWinError (GetLastError ());
363     return GNUNET_SYSERR;
364   }
365
366   if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
367   {
368     SetErrnoFromWinError (GetLastError ());
369     ret = GNUNET_SYSERR;
370   }
371   else
372     ret = GNUNET_OK;
373
374   CloseHandle (h);
375
376   return ret;
377 #endif
378 }
379
380
381 /* end of os_priority.c */