daemon/control.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  * Copyright (C) 2008 Juuso Alasuutari <juuso.alasuutari@gmail.com>
   7  *
   8  **************************************************************************
   9  * This file contains code of the D-Bus control interface helpers
  10  **************************************************************************
  11  *
  12  * LADI Session Handler is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * LADI Session Handler is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  24  * or write to the Free Software Foundation, Inc.,
  25  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include "common.h"
  29
  30 #include "../dbus/error.h"
  31 #include "control.h"
  32 #include "../dbus_constants.h"
  33 #include "studio_internal.h"
  34
  35 #define INTERFACE_NAME IFACE_CONTROL
  36
  37 static void ladish_is_studio_loaded(struct dbus_method_call * call_ptr)
  38 {
  39   DBusMessageIter iter;
  40   dbus_bool_t is_loaded;
  41
  42   is_loaded = studio_is_loaded();
  43
  44   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
  45   if (call_ptr->reply == NULL)
  46   {
  47     goto fail;
  48   }
  49
  50   dbus_message_iter_init_append(call_ptr->reply, &iter);
  51
  52   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &is_loaded))
  53   {
  54     goto fail_unref;
  55   }
  56
  57   return;
  58
  59 fail_unref:
  60   dbus_message_unref(call_ptr->reply);
  61   call_ptr->reply = NULL;
  62
  63 fail:
  64   log_error("Ran out of memory trying to construct method return");
  65 }
  66
  67 #define array_iter_ptr ((DBusMessageIter *)context)
  68
  69 static bool get_studio_list_callback(void * call_ptr, void * context, const char * studio, uint32_t modtime)
  70 {
  71   DBusMessageIter struct_iter;
  72   DBusMessageIter dict_iter;
  73   bool ret;
  74
  75   ret = false;
  76
  77   if (!dbus_message_iter_open_container(array_iter_ptr, DBUS_TYPE_STRUCT, NULL, &struct_iter))
  78     goto exit;
  79
  80   if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &studio))
  81     goto close_struct;
  82
  83   if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
  84     goto close_struct;
  85
  86 /*   if (!maybe_add_dict_entry_string(&dict_iter, "Description", xxx)) */
  87 /*     goto close_dict; */
  88
  89   if (!dbus_add_dict_entry_uint32(&dict_iter, "Modification Time", modtime))
  90     goto close_dict;
  91
  92   ret = true;
  93
  94 close_dict:
  95   if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
  96     ret = false;
  97
  98 close_struct:
  99   if (!dbus_message_iter_close_container(array_iter_ptr, &struct_iter))
 100     ret = false;
 101
 102 exit:
 103   return ret;
 104 }
 105
 106 static void ladish_get_studio_list(struct dbus_method_call * call_ptr)
 107 {
 108   DBusMessageIter iter, array_iter;
 109
 110   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 111   if (call_ptr->reply == NULL)
 112   {
 113     goto fail;
 114   }
 115
 116   dbus_message_iter_init_append(call_ptr->reply, &iter);
 117
 118   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 119   {
 120     goto fail_unref;
 121   }
 122
 123   if (!studios_iterate(call_ptr, &array_iter, get_studio_list_callback))
 124   {
 125     dbus_message_iter_close_container(&iter, &array_iter);
 126     if (call_ptr->reply == NULL)
 127       goto fail_unref;
 128
 129     /* studios_iterate or get_studio_list_callback() composed error reply */
 130     return;
 131   }
 132
 133   if (!dbus_message_iter_close_container(&iter, &array_iter))
 134   {
 135     goto fail_unref;
 136   }
 137
 138   return;
 139
 140 fail_unref:
 141   dbus_message_unref(call_ptr->reply);
 142   call_ptr->reply = NULL;
 143
 144 fail:
 145   log_error("Ran out of memory trying to construct method return");
 146 }
 147
 148 static void ladish_load_studio(struct dbus_method_call * call_ptr)
 149 {
 150   const char * name;
 151
 152   dbus_error_init(&g_dbus_error);
 153
 154   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 155   {
 156     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 157     dbus_error_free(&g_dbus_error);
 158     return;
 159   }
 160
 161   log_info("Load studio request (%s)", name);
 162
 163   if (ladish_command_load_studio(call_ptr, &g_studio.cmd_queue, name))
 164   {
 165     method_return_new_void(call_ptr);
 166   }
 167 }
 168
 169 static void ladish_delete_studio(struct dbus_method_call * call_ptr)
 170 {
 171   const char * name;
 172
 173   dbus_error_init(&g_dbus_error);
 174
 175   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 176   {
 177     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 178     dbus_error_free(&g_dbus_error);
 179     return;
 180   }
 181
 182   if (studio_delete(call_ptr, name))
 183   {
 184     method_return_new_void(call_ptr);
 185   }
 186 }
 187
 188 static void ladish_new_studio(struct dbus_method_call * call_ptr)
 189 {
 190   const char * name;
 191
 192   dbus_error_init(&g_dbus_error);
 193
 194   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 195   {
 196     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 197     dbus_error_free(&g_dbus_error);
 198     return;
 199   }
 200
 201   log_info("New studio request (%s)", name);
 202
 203   if (ladish_command_new_studio(call_ptr, &g_studio.cmd_queue, name))
 204   {
 205     method_return_new_void(call_ptr);
 206   }
 207 }
 208
 209 static void ladish_get_application_list(struct dbus_method_call * call_ptr)
 210 {
 211   DBusMessageIter iter;
 212   DBusMessageIter array_iter;
 213 #if 0
 214   DBusMessageIter struct_iter;
 215   DBusMessageIter dict_iter;
 216   struct list_head * node_ptr;
 217   struct lash_appdb_entry * entry_ptr;
 218 #endif
 219
 220   log_info("Getting applications list");
 221
 222   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 223   if (call_ptr->reply == NULL)
 224   {
 225     goto fail;
 226   }
 227
 228   dbus_message_iter_init_append(call_ptr->reply, &iter);
 229
 230   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 231   {
 232     goto fail_unref;
 233   }
 234
 235 #if 0
 236   list_for_each(node_ptr, &g_server->appdb)
 237   {
 238     entry_ptr = list_entry(node_ptr, struct lash_appdb_entry, siblings);
 239
 240     if (!dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 241       goto fail_unref;
 242
 243     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, (const void *) &entry_ptr->name))
 244     {
 245       dbus_message_iter_close_container(&iter, &array_iter);
 246       goto fail_unref;
 247     }
 248
 249     if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 250       goto fail_unref;
 251
 252     if (!maybe_add_dict_entry_string(&dict_iter, "GenericName", entry_ptr->generic_name))
 253       goto fail_unref;
 254
 255     if (!maybe_add_dict_entry_string(&dict_iter, "Comment", entry_ptr->comment))
 256       goto fail_unref;
 257
 258     if (!maybe_add_dict_entry_string(&dict_iter, "Icon", entry_ptr->icon))
 259       goto fail_unref;
 260
 261     if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 262       goto fail_unref;
 263
 264     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
 265       goto fail_unref;
 266   }
 267 #endif
 268
 269   if (!dbus_message_iter_close_container(&iter, &array_iter))
 270   {
 271     goto fail_unref;
 272   }
 273
 274   return;
 275
 276 fail_unref:
 277   dbus_message_unref(call_ptr->reply);
 278   call_ptr->reply = NULL;
 279 fail:
 280   return;
 281 }
 282
 283 static void ladish_exit(struct dbus_method_call * call_ptr)
 284 {
 285   log_info("Exit command received through D-Bus");
 286
 287   if (!ladish_command_exit(NULL, &g_studio.cmd_queue))
 288   { /* if queuing of command failed, force exit anyway,
 289        JACK server will be left started,
 290        but refusing exit command is worse */
 291     g_quit = true;
 292   }
 293
 294   method_return_new_void(call_ptr);
 295 }
 296
 297 void emit_studio_appeared()
 298 {
 299   dbus_signal_emit(g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "StudioAppeared", "");
 300 }
 301
 302 void emit_studio_disappeared()
 303 {
 304   dbus_signal_emit(g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "StudioDisappeared", "");
 305 }
 306
 307 METHOD_ARGS_BEGIN(IsStudioLoaded, "Check whether studio D-Bus object is present")
 308   METHOD_ARG_DESCRIBE_OUT("present", "b", "Whether studio D-Bus object is present")
 309 METHOD_ARGS_END
 310
 311 METHOD_ARGS_BEGIN(GetStudioList, "Get list of studios")
 312   METHOD_ARG_DESCRIBE_OUT("studio_list", "a(sa{sv})", "List of studios, name and properties")
 313 METHOD_ARGS_END
 314
 315 METHOD_ARGS_BEGIN(NewStudio, "New studio")
 316   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio, if empty name will be generated")
 317 METHOD_ARGS_END
 318
 319 METHOD_ARGS_BEGIN(LoadStudio, "Load studio")
 320   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio to load")
 321   METHOD_ARG_DESCRIBE_IN("options", "a{sv}", "Load options")
 322 METHOD_ARGS_END
 323
 324 METHOD_ARGS_BEGIN(DeleteStudio, "Delete studio")
 325   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio to delete")
 326 METHOD_ARGS_END
 327
 328 METHOD_ARGS_BEGIN(GetApplicationList, "Get list of applications that can be launched")
 329   METHOD_ARG_DESCRIBE_OUT("applications", "a(sa{sv})", "List of applications, name and properties")
 330 METHOD_ARGS_END
 331
 332 METHOD_ARGS_BEGIN(Exit, "Tell ladish D-Bus service to exit")
 333 METHOD_ARGS_END
 334
 335 METHODS_BEGIN
 336   METHOD_DESCRIBE(IsStudioLoaded, ladish_is_studio_loaded)
 337   METHOD_DESCRIBE(GetStudioList, ladish_get_studio_list)
 338   METHOD_DESCRIBE(NewStudio, ladish_new_studio)
 339   METHOD_DESCRIBE(LoadStudio, ladish_load_studio)
 340   METHOD_DESCRIBE(DeleteStudio, ladish_delete_studio)
 341   METHOD_DESCRIBE(GetApplicationList, ladish_get_application_list)
 342   METHOD_DESCRIBE(Exit, ladish_exit)
 343 METHODS_END
 344
 345 SIGNAL_ARGS_BEGIN(StudioAppeared, "Studio D-Bus object appeared")
 346 SIGNAL_ARGS_END
 347
 348 SIGNAL_ARGS_BEGIN(StudioDisappeared, "Studio D-Bus object disappeared")
 349 SIGNAL_ARGS_END
 350
 351 SIGNALS_BEGIN
 352   SIGNAL_DESCRIBE(StudioAppeared)
 353   SIGNAL_DESCRIBE(StudioDisappeared)
 354 SIGNALS_END
 355
 356 /*
 357  * Interface description.
 358  */
 359
 360 INTERFACE_BEGIN(g_lashd_interface_control, INTERFACE_NAME)
 361   INTERFACE_DEFAULT_HANDLER
 362   INTERFACE_EXPOSE_METHODS
 363   INTERFACE_EXPOSE_SIGNALS
 364 INTERFACE_END