xref: /titanic_41/usr/src/cmd/hal/hald-runner/runner.c (revision 3ab06c272dba4a37b5b352788c61484729197623)
1 /***************************************************************************
2  * CVSID: $Id$
3  *
4  * runner.c - Process running code
5  *
6  * Copyright (C) 2006 Sjoerd Simons, <sjoerd@luon.net>
7  * Copyright (C) 2007 Codethink Ltd. Author Rob Taylor <rob.taylor@codethink.co.uk>
8  *
9  * Licensed under the Academic Free License version 2.1
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
24  *
25  **************************************************************************/
26 #include <stdio.h>
27 #include <unistd.h>
28 #include <stdlib.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <sys/wait.h>
32 #include <signal.h>
33 #include <string.h>
34 
35 #define DBUS_API_SUBJECT_TO_CHANGE
36 #include <dbus/dbus-glib-lowlevel.h>
37 
38 #include <glib.h>
39 #include "utils.h"
40 #include "runner.h"
41 
42 /* Successful run of the program */
43 #define HALD_RUN_SUCCESS 0x0
44 /* Process was killed because of running too long */
45 #define  HALD_RUN_TIMEOUT 0x1
46 /* Failed to start for some reason */
47 #define HALD_RUN_FAILED 0x2
48 /* Killed on purpose, e.g. hal_util_kill_device_helpers */
49 #define HALD_RUN_KILLED 0x4
50 
51 GHashTable *udi_hash = NULL;
52 GList *singletons = NULL;
53 
54 typedef struct {
55 	run_request *r;
56 	DBusMessage *msg;
57 	DBusConnection *con;
58 	GPid pid;
59 	gint stderr_v;
60 	guint watch;
61 	guint timeout;
62 	gboolean sent_kill;
63 	gboolean emit_pid_exited;
64 } run_data;
65 
66 static void
del_run_data(run_data * rd)67 del_run_data(run_data *rd)
68 {
69 	if (rd == NULL)
70 		return;
71 
72 	del_run_request(rd->r);
73 	if (rd->msg)
74 		dbus_message_unref(rd->msg);
75 
76 	g_spawn_close_pid(rd->pid);
77 
78 	if (rd->stderr_v >= 0)
79 		close(rd->stderr_v);
80 
81 	if (rd->timeout != 0)
82 		g_source_remove(rd->timeout);
83 
84 	g_free(rd);
85 }
86 
87 run_request *
new_run_request(void)88 new_run_request(void)
89 {
90 	run_request *result;
91 	result = g_new0(run_request, 1);
92 	g_assert(result != NULL);
93 	return result;
94 }
95 
96 void
del_run_request(run_request * r)97 del_run_request(run_request *r)
98 {
99 	if (r == NULL)
100 		return;
101 	g_free(r->udi);
102 	free_string_array(r->environment);
103 	free_string_array(r->argv);
104 	g_free(r->input);
105 	g_free(r);
106 }
107 
108 static void
send_reply(DBusConnection * con,DBusMessage * msg,guint32 exit_type,gint32 return_code,gchar ** error)109 send_reply(DBusConnection *con, DBusMessage *msg, guint32 exit_type, gint32 return_code, gchar **error)
110 {
111 	DBusMessage *reply;
112 	DBusMessageIter iter;
113 	int i;
114 
115 	if (con == NULL || msg == NULL)
116 		return;
117 
118 	reply = dbus_message_new_method_return(msg);
119 	g_assert(reply != NULL);
120 
121 	dbus_message_iter_init_append(reply, &iter);
122 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &exit_type);
123 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &return_code);
124 	if (error != NULL) for (i = 0; error[i] != NULL; i++) {
125 		dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &error[i]);
126 	}
127 
128 	dbus_connection_send(con, reply, NULL);
129 	dbus_message_unref(reply);
130 }
131 
132 static void
remove_run_data(run_data * rd)133 remove_run_data(run_data *rd)
134 {
135 	GList *list;
136 
137 	if (rd->r->is_singleton) {
138 		singletons = g_list_remove(singletons, rd);
139 	} else {
140 		/* Remove to the hashtable */
141 		list = (GList *)g_hash_table_lookup(udi_hash, rd->r->udi);
142 		list = g_list_remove(list, rd);
143 		/* The hash table will take care to not leak the dupped string */
144 		g_hash_table_insert(udi_hash, g_strdup(rd->r->udi), list);
145 	}
146 }
147 
148 static void
run_exited(GPid pid,gint status,gpointer data)149 run_exited(GPid pid, gint status, gpointer data)
150 {
151 	run_data *rd = (run_data *)data;
152 	char **error = NULL;
153 
154 	printf("pid %d: rc=%d signaled=%d: %s\n",
155                pid, WEXITSTATUS(status), WIFSIGNALED(status), rd->r->argv[0]);
156 	rd->watch = 0;
157 	if (rd->sent_kill == TRUE) {
158 		/* We send it a kill, so ignore */
159 		del_run_data(rd);
160 		return;
161 	}
162 	/* Check if it was a normal exit */
163 	if (!WIFEXITED(status)) {
164 		/* No not normal termination ? crash ? */
165 		send_reply(rd->con, rd->msg, HALD_RUN_FAILED, 0, NULL);
166 		goto out;
167 	}
168 	/* normal exit */
169 	if (rd->stderr_v >= 0) {
170 		/* Need to read stderr */
171 		error = get_string_array_from_fd(rd->stderr_v);
172 		close(rd->stderr_v);
173 		rd->stderr_v = -1;
174 	}
175 	if (rd->msg != NULL)
176 		send_reply(rd->con, rd->msg, HALD_RUN_SUCCESS, WEXITSTATUS(status), error);
177 	free_string_array(error);
178 
179 out:
180 	remove_run_data (rd);
181 
182 	/* emit a signal that this PID exited */
183 	if(rd->con != NULL && rd->emit_pid_exited) {
184 		DBusMessage *signal;
185 		gint64 ppid = rd->pid;
186 		signal = dbus_message_new_signal ("/org/freedesktop/HalRunner",
187 						  "org.freedesktop.HalRunner",
188 						  "StartedProcessExited");
189 		dbus_message_append_args (signal,
190 					  DBUS_TYPE_INT64, &(ppid),
191 					  DBUS_TYPE_INVALID);
192 		dbus_connection_send(rd->con, signal, NULL);
193 	}
194 
195 	del_run_data(rd);
196 }
197 
198 static gboolean
run_timedout(gpointer data)199 run_timedout(gpointer data) {
200 	run_data *rd = (run_data *)data;
201 	/* Time is up, kill the process, send reply that it was killed!
202 	 * Don't wait for exit, because it could hang in state D
203 	 */
204 	kill(rd->pid, SIGTERM);
205 	/* Ensure the timeout is not removed in the delete */
206 	rd->timeout = 0;
207 	/* So the exit watch will know it's killed  in case it runs*/
208 	rd->sent_kill = TRUE;
209 
210 	send_reply(rd->con, rd->msg, HALD_RUN_TIMEOUT, 0, NULL);
211 	remove_run_data (rd);
212 	return FALSE;
213 }
214 
215 static gboolean
find_program(char ** argv)216 find_program(char **argv)
217 {
218 	/* Search for the program in the dirs where it's allowed to be */
219 	char *program;
220 	char *path = NULL;
221 
222 	if (argv[0] == NULL)
223 		return FALSE;
224 
225 	program = g_path_get_basename(argv[0]);
226 
227 	/* first search $PATH to make e.g. run-hald.sh work */
228 	path = g_find_program_in_path (program);
229 	g_free(program);
230 	if (path == NULL)
231 		return FALSE;
232 	else {
233 		/* Replace program in argv[0] with the full path */
234 		g_free(argv[0]);
235 		argv[0] = path;
236 	}
237 	return TRUE;
238 }
239 
240 /* Run the given request and reply it's result on msg */
241 gboolean
run_request_run(run_request * r,DBusConnection * con,DBusMessage * msg,GPid * out_pid)242 run_request_run (run_request *r, DBusConnection *con, DBusMessage *msg, GPid *out_pid)
243 {
244 	GPid pid;
245 	GError *error = NULL;
246 	gint *stdin_p = NULL;
247 	gint *stderr_p = NULL;
248 	gint stdin_v;
249 	gint stderr_v = -1;
250 	run_data *rd = NULL;
251 	gboolean program_exists = FALSE;
252 	char *program_dir = NULL;
253 	GList *list;
254 
255 	printf("Run started %s (%u) (%d) \n!", r->argv[0], r->timeout,
256 		r->error_on_stderr);
257 	if (r->input != NULL) {
258 		stdin_p = &stdin_v;
259 	}
260 	if (r->error_on_stderr) {
261 		stderr_p = &stderr_v;
262 	}
263 
264 	program_exists = find_program(r->argv);
265 
266 	if (program_exists) {
267 		program_dir = g_path_get_dirname (r->argv[0]);
268 		printf("  full path is '%s', program_dir is '%s'\n", r->argv[0], program_dir);
269 	}
270 
271 	if (!program_exists ||
272 		!g_spawn_async_with_pipes(program_dir, r->argv, r->environment,
273 		                          G_SPAWN_DO_NOT_REAP_CHILD,
274 		                          NULL, NULL, &pid,
275 		                          stdin_p, NULL, stderr_p, &error)) {
276 		g_free (program_dir);
277 		del_run_request(r);
278 		if (con && msg)
279 			send_reply(con, msg, HALD_RUN_FAILED, 0, NULL);
280 		return FALSE;
281 	}
282 	g_free (program_dir);
283 
284 	if (r->input) {
285 		if (write(stdin_v, r->input, strlen(r->input)) != (ssize_t) strlen(r->input))
286 			printf("Warning: Error while writing r->input (%s) to stdin_v.\n", r->input);
287 		close(stdin_v);
288 	}
289 
290 	rd = g_new0(run_data,1);
291 	g_assert(rd != NULL);
292 	rd->r = r;
293 	rd->msg = msg;
294 	if (msg != NULL)
295 		dbus_message_ref(msg);
296 
297 	rd->con = con;
298 	rd->pid = pid;
299 	rd->stderr_v = stderr_v;
300 	rd->sent_kill = FALSE;
301 
302 	/* Add watch for exit of the program */
303 	rd->watch = g_child_watch_add(pid, run_exited, rd);
304 
305 	/* Add timeout if needed */
306 	if (r->timeout > 0)
307 		rd->timeout = g_timeout_add(r->timeout, run_timedout, rd);
308 	else
309 		rd->timeout = 0;
310 
311 	if (r->is_singleton) {
312 		singletons = g_list_prepend(singletons, rd);
313 	} else {
314 		/* Add to the hashtable */
315 		list = (GList *)g_hash_table_lookup(udi_hash, r->udi);
316 		list = g_list_prepend(list, rd);
317 
318 		/* The hash table will take care to not leak the dupped string */
319 		g_hash_table_insert(udi_hash, g_strdup(r->udi), list);
320 	}
321 
322 	/* send back PID if requested.. and only emit StartedProcessExited in this case */
323 	if (out_pid != NULL) {
324 		*out_pid = pid;
325 		rd->emit_pid_exited = TRUE;
326 	}
327 	return TRUE;
328 }
329 
330 static void
kill_rd(gpointer data,gpointer user_data)331 kill_rd(gpointer data, gpointer user_data)
332 {
333 	run_data *rd = (run_data *)data;
334 
335 	kill(rd->pid, SIGTERM);
336 	printf("Sent kill to %d\n", rd->pid);
337 	if (rd->timeout != 0) {
338 		/* Remove the timeout watch */
339 		g_source_remove(rd->timeout);
340 		rd->timeout = 0;
341 	}
342 
343 	/* So the exit watch will know it's killed  in case it runs */
344 	rd->sent_kill = TRUE;
345 
346 	if (rd->msg != NULL)
347 		send_reply(rd->con, rd->msg, HALD_RUN_KILLED, 0, NULL);
348 }
349 
350 static void
do_kill_udi(gchar * udi)351 do_kill_udi(gchar *udi)
352 {
353 	GList *list;
354 	list = (GList *)g_hash_table_lookup(udi_hash, udi);
355 	g_list_foreach(list, kill_rd, NULL);
356 	g_list_free(list);
357 }
358 
359 /* Kill all running request for a udi */
360 void
run_kill_udi(gchar * udi)361 run_kill_udi(gchar *udi)
362 {
363 	do_kill_udi(udi);
364 	g_hash_table_remove(udi_hash, udi);
365 }
366 
367 static gboolean
hash_kill_udi(gpointer key,gpointer value,gpointer user_data)368 hash_kill_udi(gpointer key, gpointer value, gpointer user_data) {
369 	do_kill_udi(key);
370 	return TRUE;
371 }
372 
373 /* Kill all running request*/
374 void
run_kill_all()375 run_kill_all()
376 {
377 	g_hash_table_foreach_remove(udi_hash, hash_kill_udi, NULL);
378 	g_list_foreach(singletons, kill_rd, NULL);
379 }
380 
381 void
run_init()382 run_init()
383 {
384 	udi_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
385 }
386