5 * Copyright (C) 2007-2010 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
36 connman_task_notify_t func;
46 connman_task_exit_t exit_func;
51 static GHashTable *task_hash = NULL;
53 static volatile gint task_counter;
55 static DBusConnection *connection;
57 static void free_pointer(gpointer data, gpointer user_data)
62 static void free_task(gpointer data)
64 struct connman_task *task = data;
68 g_hash_table_destroy(task->notify);
72 kill(task->pid, SIGTERM);
74 if (task->child_watch > 0)
75 g_source_remove(task->child_watch);
77 g_ptr_array_foreach(task->envp, free_pointer, NULL);
78 g_ptr_array_free(task->envp, TRUE);
80 g_ptr_array_foreach(task->argv, free_pointer, NULL);
81 g_ptr_array_free(task->argv, TRUE);
88 * connman_task_create:
89 * @program: name of executable
91 * Allocate a new task of given #program
93 * Returns: a newly-allocated #connman_task structure
95 struct connman_task *connman_task_create(const char *program)
97 struct connman_task *task;
103 task = g_try_new0(struct connman_task, 1);
107 counter = g_atomic_int_exchange_and_add(&task_counter, 1);
109 task->path = g_strdup_printf("/task/%d", counter);
112 task->argv = g_ptr_array_new();
113 task->envp = g_ptr_array_new();
115 str = g_strdup(program);
116 g_ptr_array_add(task->argv, str);
118 task->notify = g_hash_table_new_full(g_str_hash, g_str_equal,
121 DBG("task %p", task);
123 g_hash_table_insert(task_hash, task->path, task);
129 * connman_task_destory:
130 * @task: task structure
132 * Remove and destory #task
134 void connman_task_destroy(struct connman_task *task)
136 DBG("task %p", task);
138 g_hash_table_remove(task_hash, task->path);
142 * connman_task_get_path:
143 * @task: task structure
147 const char *connman_task_get_path(struct connman_task *task)
153 * connman_task_add_argument:
154 * @task: task structure
155 * @name: argument name
156 * @format: format string
157 * @Varargs: list of arguments
159 * Add a new command line argument
161 int connman_task_add_argument(struct connman_task *task,
162 const char *name, const char *format, ...)
167 DBG("task %p arg %s", task, name);
172 str = g_strdup(name);
173 g_ptr_array_add(task->argv, str);
175 va_start(ap, format);
177 if (format != NULL) {
178 str = g_strdup_vprintf(format, ap);
179 g_ptr_array_add(task->argv, str);
188 * connman_task_add_variable:
189 * @task: task structure
190 * @key: variable name
191 * @format: format string
192 * @Varargs: list of arguments
194 * Add a new environment variable
196 int connman_task_add_variable(struct connman_task *task,
197 const char *key, const char *format, ...)
202 DBG("task %p key %s", task, key);
207 va_start(ap, format);
209 val = g_strdup_vprintf(format, ap);
210 str = g_strdup_printf("%s=%s", key, format ? format : "");
211 g_ptr_array_add(task->envp, str);
220 * connman_task_set_notify:
221 * @task: task structure
222 * @member: notifcation method name
223 * @function: notification callback
224 * @user_data: optional notification user data
226 * Set notification handler for #member
228 int connman_task_set_notify(struct connman_task *task, const char *member,
229 connman_task_notify_t function, void *user_data)
231 struct notify_data *notify;
233 DBG("task %p", task);
235 notify = g_try_new0(struct notify_data, 1);
239 notify->func = function;
240 notify->data = user_data;
242 g_hash_table_insert(task->notify, g_strdup(member), notify);
247 static void task_died(GPid pid, gint status, gpointer user_data)
249 struct connman_task *task = user_data;
252 if (WIFEXITED(status)) {
253 exit_code = WEXITSTATUS(status);
254 DBG("task %p exit status %d", task, exit_code);
257 DBG("task %p signal %d", task, WTERMSIG(status));
260 g_spawn_close_pid(pid);
263 task->child_watch = 0;
266 task->exit_func(task, exit_code, task->exit_data);
269 static void task_setup(gpointer user_data)
271 struct connman_task *task = user_data;
273 DBG("task %p", task);
278 * @task: task structure
279 * @function: exit callback
280 * @user_data: optional exit user data
281 * @fd: optional spawn with pipe
283 * Execute program specified by #task
285 int connman_task_run(struct connman_task *task,
286 connman_task_exit_t function, void *user_data,
287 int *stdin_fd, int *stdout_fd, int *stderr_fd)
289 GSpawnFlags flags = G_SPAWN_DO_NOT_REAP_CHILD;
293 DBG("task %p", task);
298 if (stdout_fd == NULL)
299 flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
301 if (stderr_fd == NULL)
302 flags |= G_SPAWN_STDERR_TO_DEV_NULL;
304 task->exit_func = function;
305 task->exit_data = user_data;
307 if (g_ptr_array_index(task->argv, task->argv->len - 1) != NULL)
308 g_ptr_array_add(task->argv, NULL);
310 if (task->envp->len == 0 || g_ptr_array_index(task->envp,
311 task->envp->len - 1) != NULL) {
312 if (g_hash_table_size(task->notify) > 0) {
316 busname = dbus_bus_get_unique_name(connection);
317 str = g_strdup_printf("CONNMAN_BUSNAME=%s", busname);
318 g_ptr_array_add(task->envp, str);
320 str = g_strdup_printf("CONNMAN_INTERFACE=%s",
321 CONNMAN_TASK_INTERFACE);
322 g_ptr_array_add(task->envp, str);
324 str = g_strdup_printf("CONNMAN_PATH=%s", task->path);
325 g_ptr_array_add(task->envp, str);
328 g_ptr_array_add(task->envp, NULL);
331 argv = (char **) task->argv->pdata;
332 envp = (char **) task->envp->pdata;
334 result = g_spawn_async_with_pipes(NULL, argv, envp, flags,
335 task_setup, task, &task->pid,
336 stdin_fd, stdout_fd, stderr_fd, NULL);
337 if (result == FALSE) {
338 connman_error("Failed to spawn %s", argv[0]);
342 task->child_watch = g_child_watch_add(task->pid, task_died, task);
349 * @task: task structure
351 * Stop program specified by #task
353 int connman_task_stop(struct connman_task *task)
355 DBG("task %p", task);
358 kill(task->pid, SIGTERM);
363 static DBusHandlerResult task_filter(DBusConnection *connection,
364 DBusMessage *message, void *user_data)
366 struct connman_task *task;
367 struct notify_data *notify;
368 const char *path, *member;
370 if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
371 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
373 if (dbus_message_has_interface(message,
374 CONNMAN_TASK_INTERFACE) == FALSE)
375 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
377 path = dbus_message_get_path(message);
379 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
381 task = g_hash_table_lookup(task_hash, path);
383 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
385 if (dbus_message_get_no_reply(message) == FALSE) {
388 reply = dbus_message_new_method_return(message);
390 return DBUS_HANDLER_RESULT_NEED_MEMORY;
392 dbus_connection_send(connection, reply, NULL);
394 dbus_message_unref(reply);
397 member = dbus_message_get_member(message);
399 return DBUS_HANDLER_RESULT_HANDLED;
401 notify = g_hash_table_lookup(task->notify, member);
403 return DBUS_HANDLER_RESULT_HANDLED;
406 notify->func(task, message, notify->data);
408 return DBUS_HANDLER_RESULT_HANDLED;
411 static const char *task_rule = "type=method_call"
412 ",interface=" CONNMAN_TASK_INTERFACE;
414 int __connman_task_init(void)
418 connection = connman_dbus_get_connection();
420 dbus_connection_add_filter(connection, task_filter, NULL, NULL);
422 g_atomic_int_set(&task_counter, 0);
424 task_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
427 dbus_bus_add_match(connection, task_rule, NULL);
428 dbus_connection_flush(connection);
433 void __connman_task_cleanup(void)
437 dbus_bus_remove_match(connection, task_rule, NULL);
438 dbus_connection_flush(connection);
440 g_hash_table_destroy(task_hash);
443 dbus_connection_remove_filter(connection, task_filter, NULL);
445 dbus_connection_unref(connection);