daemon/control.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008,2009,2010,2011,2012 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 #include "studio.h"
  30 #include "control.h"
  31 #include "../dbus_constants.h"
  32 #include "cmd.h"
  33 #include "room.h"
  34 #include "../lib/wkports.h"
  35 #include "../proxies/conf_proxy.h"
  36 #include "conf.h"
  37
  38 #define INTERFACE_NAME IFACE_CONTROL
  39
  40 /* 805e485f-65e4-4c37-a959-2a3b60b3c270 */
  41 UUID_DEFINE(empty_room,0x80,0x5E,0x48,0x5F,0x65,0xE4,0x4C,0x37,0xA9,0x59,0x2A,0x3B,0x60,0xB3,0xC2,0x70);
  42
  43 /* c603f2a0-d96a-493e-a8cf-55581d950aa9 */
  44 UUID_DEFINE(basic_room,0xC6,0x03,0xF2,0xA0,0xD9,0x6A,0x49,0x3E,0xA8,0xCF,0x55,0x58,0x1D,0x95,0x0A,0xA9);
  45
  46 /* f3c6070d-e60f-4449-8b62-8c232df3eb2c */
  47 /* room with 4 audio capture ports, 4 audio playback ports, 2 midi capture ports and 2 midi playback ports */
  48 UUID_DEFINE(router_4x4x2x2_room,0xF3,0xC6,0x07,0x0D,0xE6,0x0F,0x44,0x49,0x8B,0x62,0x8C,0x23,0x2D,0xF3,0xEB,0x2C);
  49
  50 /* a791a5f7-a6a2-44d5-9113-9115960300a4 */
  51 /* room with 10 audio capture ports, 10 audio playback ports, 4 midi capture ports and 4 midi playback ports */
  52 UUID_DEFINE(router_10x10x4x4_room,0xA7,0x91,0xA5,0xF7,0xA6,0xA2,0x44,0xD5,0x91,0x13,0x91,0x15,0x96,0x03,0x00,0xA4);
  53
  54 /* 42d580f4-c5e5-4909-bc65-dfd96b3cbfce */
  55 /* room with 40 audio capture ports, 40 audio playback ports, 16 midi capture ports and 16 midi playback ports */
  56 UUID_DEFINE(router_40x40x16x16_room,0x42,0xD5,0x80,0xF4,0xC5,0xE5,0x49,0x09,0xBC,0x65,0xDF,0xD9,0x6B,0x3C,0xBF,0xCE);
  57
  58 const unsigned char * ladish_wkport_router_audio_capture[] =
  59 {
  60   ladish_wkport_router_audio_capture_1,
  61   ladish_wkport_router_audio_capture_2,
  62   ladish_wkport_router_audio_capture_3,
  63   ladish_wkport_router_audio_capture_4,
  64   ladish_wkport_router_audio_capture_5,
  65   ladish_wkport_router_audio_capture_6,
  66   ladish_wkport_router_audio_capture_7,
  67   ladish_wkport_router_audio_capture_8,
  68   ladish_wkport_router_audio_capture_9,
  69   ladish_wkport_router_audio_capture_10,
  70   ladish_wkport_router_audio_capture_11,
  71   ladish_wkport_router_audio_capture_12,
  72   ladish_wkport_router_audio_capture_13,
  73   ladish_wkport_router_audio_capture_14,
  74   ladish_wkport_router_audio_capture_15,
  75   ladish_wkport_router_audio_capture_16,
  76   ladish_wkport_router_audio_capture_17,
  77   ladish_wkport_router_audio_capture_18,
  78   ladish_wkport_router_audio_capture_19,
  79   ladish_wkport_router_audio_capture_20,
  80   ladish_wkport_router_audio_capture_21,
  81   ladish_wkport_router_audio_capture_22,
  82   ladish_wkport_router_audio_capture_23,
  83   ladish_wkport_router_audio_capture_24,
  84   ladish_wkport_router_audio_capture_25,
  85   ladish_wkport_router_audio_capture_26,
  86   ladish_wkport_router_audio_capture_27,
  87   ladish_wkport_router_audio_capture_28,
  88   ladish_wkport_router_audio_capture_29,
  89   ladish_wkport_router_audio_capture_30,
  90   ladish_wkport_router_audio_capture_31,
  91   ladish_wkport_router_audio_capture_32,
  92   ladish_wkport_router_audio_capture_33,
  93   ladish_wkport_router_audio_capture_34,
  94   ladish_wkport_router_audio_capture_35,
  95   ladish_wkport_router_audio_capture_36,
  96   ladish_wkport_router_audio_capture_37,
  97   ladish_wkport_router_audio_capture_38,
  98   ladish_wkport_router_audio_capture_39,
  99   ladish_wkport_router_audio_capture_40,
 100 };
 101
 102 const unsigned char * ladish_wkport_router_audio_playback[] =
 103 {
 104   ladish_wkport_router_audio_playback_1,
 105   ladish_wkport_router_audio_playback_2,
 106   ladish_wkport_router_audio_playback_3,
 107   ladish_wkport_router_audio_playback_4,
 108   ladish_wkport_router_audio_playback_5,
 109   ladish_wkport_router_audio_playback_6,
 110   ladish_wkport_router_audio_playback_7,
 111   ladish_wkport_router_audio_playback_8,
 112   ladish_wkport_router_audio_playback_9,
 113   ladish_wkport_router_audio_playback_10,
 114   ladish_wkport_router_audio_playback_11,
 115   ladish_wkport_router_audio_playback_12,
 116   ladish_wkport_router_audio_playback_13,
 117   ladish_wkport_router_audio_playback_14,
 118   ladish_wkport_router_audio_playback_15,
 119   ladish_wkport_router_audio_playback_16,
 120   ladish_wkport_router_audio_playback_17,
 121   ladish_wkport_router_audio_playback_18,
 122   ladish_wkport_router_audio_playback_19,
 123   ladish_wkport_router_audio_playback_20,
 124   ladish_wkport_router_audio_playback_21,
 125   ladish_wkport_router_audio_playback_22,
 126   ladish_wkport_router_audio_playback_23,
 127   ladish_wkport_router_audio_playback_24,
 128   ladish_wkport_router_audio_playback_25,
 129   ladish_wkport_router_audio_playback_26,
 130   ladish_wkport_router_audio_playback_27,
 131   ladish_wkport_router_audio_playback_28,
 132   ladish_wkport_router_audio_playback_29,
 133   ladish_wkport_router_audio_playback_30,
 134   ladish_wkport_router_audio_playback_31,
 135   ladish_wkport_router_audio_playback_32,
 136   ladish_wkport_router_audio_playback_33,
 137   ladish_wkport_router_audio_playback_34,
 138   ladish_wkport_router_audio_playback_35,
 139   ladish_wkport_router_audio_playback_36,
 140   ladish_wkport_router_audio_playback_37,
 141   ladish_wkport_router_audio_playback_38,
 142   ladish_wkport_router_audio_playback_39,
 143   ladish_wkport_router_audio_playback_40,
 144 };
 145
 146 const unsigned char * ladish_wkport_router_midi_capture[] =
 147 {
 148   ladish_wkport_router_midi_capture_1,
 149   ladish_wkport_router_midi_capture_2,
 150   ladish_wkport_router_midi_capture_3,
 151   ladish_wkport_router_midi_capture_4,
 152   ladish_wkport_router_midi_capture_5,
 153   ladish_wkport_router_midi_capture_6,
 154   ladish_wkport_router_midi_capture_7,
 155   ladish_wkport_router_midi_capture_8,
 156   ladish_wkport_router_midi_capture_9,
 157   ladish_wkport_router_midi_capture_10,
 158   ladish_wkport_router_midi_capture_11,
 159   ladish_wkport_router_midi_capture_12,
 160   ladish_wkport_router_midi_capture_13,
 161   ladish_wkport_router_midi_capture_14,
 162   ladish_wkport_router_midi_capture_15,
 163   ladish_wkport_router_midi_capture_16,
 164 };
 165
 166 const unsigned char * ladish_wkport_router_midi_playback[] =
 167 {
 168   ladish_wkport_router_midi_playback_1,
 169   ladish_wkport_router_midi_playback_2,
 170   ladish_wkport_router_midi_playback_3,
 171   ladish_wkport_router_midi_playback_4,
 172   ladish_wkport_router_midi_playback_5,
 173   ladish_wkport_router_midi_playback_6,
 174   ladish_wkport_router_midi_playback_7,
 175   ladish_wkport_router_midi_playback_8,
 176   ladish_wkport_router_midi_playback_9,
 177   ladish_wkport_router_midi_playback_10,
 178   ladish_wkport_router_midi_playback_11,
 179   ladish_wkport_router_midi_playback_12,
 180   ladish_wkport_router_midi_playback_13,
 181   ladish_wkport_router_midi_playback_14,
 182   ladish_wkport_router_midi_playback_15,
 183   ladish_wkport_router_midi_playback_16,
 184 };
 185
 186 static struct list_head g_room_templates;
 187
 188 static bool create_empty_room_template(const uuid_t uuid_ptr, const char * name, ladish_room_handle * room_ptr)
 189 {
 190   if (!ladish_room_create_template(uuid_ptr, name, room_ptr))
 191   {
 192     log_error("ladish_room_create_template() failed for room template \"%s\".", name);
 193     return false;
 194   }
 195
 196   return true;
 197 }
 198
 199 struct room_descriptor
 200 {
 201   const char * name;
 202   ladish_room_handle room;
 203   ladish_graph_handle graph;
 204   ladish_client_handle capture;
 205   ladish_client_handle playback;
 206 };
 207
 208 static
 209 bool
 210 create_room_template(
 211   const uuid_t uuid_ptr,
 212   const char * name,
 213   struct room_descriptor * room_descriptor_ptr)
 214 {
 215   ladish_room_handle room;
 216   ladish_graph_handle graph;
 217   ladish_client_handle capture;
 218   ladish_client_handle playback;
 219
 220   if (!create_empty_room_template(uuid_ptr, name, &room))
 221   {
 222     log_error("ladish_room_create() failed for room template \"%s\".", name);
 223     goto fail;
 224   }
 225
 226   graph = ladish_room_get_graph(room);
 227
 228   if (!ladish_client_create(ladish_wkclient_capture, &capture))
 229   {
 230     log_error("ladish_client_create() failed to create capture client to room template \"%s\".", name);
 231     goto fail_destroy;
 232   }
 233
 234   if (!ladish_graph_add_client(graph, capture, "Capture", false))
 235   {
 236     log_error("ladish_graph_add_client() failed to add capture client to room template \"%s\".", name);
 237     goto fail_destroy;
 238   }
 239
 240   if (!ladish_client_create(ladish_wkclient_playback, &playback))
 241   {
 242     log_error("ladish_client_create() failed to create playback client to room template \"%s\".", name);
 243     goto fail_destroy;
 244   }
 245
 246   if (!ladish_graph_add_client(graph, playback, "Playback", false))
 247   {
 248     log_error("ladish_graph_add_client() failed to add playback client to room template \"%s\".", name);
 249     goto fail_destroy;
 250   }
 251
 252   room_descriptor_ptr->name = ladish_room_get_name(room);
 253   room_descriptor_ptr->room = room;
 254   room_descriptor_ptr->graph = graph;
 255   room_descriptor_ptr->capture = capture;
 256   room_descriptor_ptr->playback = playback;
 257
 258   return true;
 259
 260 fail_destroy:
 261   ladish_room_destroy(room);    /* this will destroy the graph clients as well */
 262 fail:
 263   return false;
 264 }
 265
 266 static
 267 bool
 268 create_room_template_port(
 269   struct room_descriptor * room_descriptor_ptr,
 270   const uuid_t uuid_ptr,
 271   const char * name,
 272   uint32_t type,
 273   uint32_t flags)
 274 {
 275   ladish_port_handle port;
 276   bool playback;
 277   ladish_client_handle client;
 278
 279   playback = JACKDBUS_PORT_IS_INPUT(flags);
 280   ASSERT(playback || JACKDBUS_PORT_IS_OUTPUT(flags)); /* playback or capture */
 281   ASSERT(!(playback && JACKDBUS_PORT_IS_OUTPUT(flags))); /* but not both */
 282   client = playback ? room_descriptor_ptr->playback : room_descriptor_ptr->capture;
 283
 284   if (!ladish_port_create(uuid_ptr, true, &port))
 285   {
 286     log_error("Creation of room template \"%s\" %s port \"%s\" failed.", room_descriptor_ptr->name, playback ? "playback" : "capture", name);
 287     return false;
 288   }
 289
 290   if (!ladish_graph_add_port(room_descriptor_ptr->graph, client, port, name, type, flags, false))
 291   {
 292     log_error("Adding of room template \"%s\" %s port \"%s\" to graph failed.", room_descriptor_ptr->name, playback ? "playback" : "capture", name);
 293     ladish_port_destroy(port);
 294     return false;
 295   }
 296
 297   return true;
 298 }
 299
 300 #define ADD_ROUTER_PORT(index, prefix, uuid_ptr, protocol, flags)       \
 301   sprintf(port_name_buffer, prefix "%u", index + 1);                    \
 302   if (!create_room_template_port(                                       \
 303         &room_descriptor,                                               \
 304         uuid_ptr,                                                       \
 305         port_name_buffer,                                               \
 306         protocol,                                                       \
 307         flags))                                                         \
 308   {                                                                     \
 309     goto fail;                                                          \
 310   }
 311
 312 void
 313 create_router_room_template(
 314   const uuid_t uuid_ptr,
 315   const char * name,
 316   unsigned int audio_capture,
 317   unsigned int audio_playback,
 318   unsigned int midi_capture,
 319   unsigned int midi_playback)
 320 {
 321   struct room_descriptor room_descriptor;
 322   char port_name_buffer[100];
 323   unsigned int i;
 324
 325   if (create_room_template(uuid_ptr, name, &room_descriptor))
 326   {
 327     for (i = 0; i < audio_capture; i++)
 328     {
 329       ADD_ROUTER_PORT(i, "audio_capture_", ladish_wkport_router_audio_capture[i], JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_OUTPUT);
 330     }
 331
 332     for (i = 0; i < audio_playback; i++)
 333     {
 334       ADD_ROUTER_PORT(i, "audio_playback_", ladish_wkport_router_audio_playback[i], JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT);
 335     }
 336
 337     for (i = 0; i < midi_capture; i++)
 338     {
 339       ADD_ROUTER_PORT(i, "midi_capture_", ladish_wkport_router_midi_capture[i], JACKDBUS_PORT_TYPE_MIDI, JACKDBUS_PORT_FLAG_OUTPUT);
 340     }
 341
 342     for (i = 0; i < midi_playback; i++)
 343     {
 344       ADD_ROUTER_PORT(i, "midi_playback_", ladish_wkport_router_midi_playback[i], JACKDBUS_PORT_TYPE_MIDI, JACKDBUS_PORT_FLAG_INPUT);
 345     }
 346
 347     list_add_tail(ladish_room_get_list_node(room_descriptor.room), &g_room_templates);
 348   }
 349
 350   return;
 351
 352 fail:
 353   ladish_room_destroy(room_descriptor.room); /* this will destroy the graph clients and ports as well */
 354 }
 355
 356 #undef ADD_ROUTER_PORT
 357
 358 void create_builtin_room_templates(void)
 359 {
 360   struct room_descriptor room_descriptor;
 361
 362 #if 0 /* the empty template is useless until there is a functionality to add new room ports */
 363   if (create_empty_room_template(empty_room, "Empty", &room_descriptor.room))
 364   {
 365     list_add_tail(ladish_room_get_list_node(room_descriptor.room), &g_room_templates);
 366   }
 367 #endif
 368
 369   if (create_room_template(basic_room, "Basic", &room_descriptor))
 370   {
 371     if (!create_room_template_port(&room_descriptor, ladish_wkport_capture_left, "Left", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_OUTPUT))
 372     {
 373       goto fail;
 374     }
 375
 376     if (!create_room_template_port(&room_descriptor, ladish_wkport_capture_right, "Right", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_OUTPUT))
 377     {
 378       goto fail;
 379     }
 380
 381     if (!create_room_template_port(&room_descriptor, ladish_wkport_midi_capture, "MIDI", JACKDBUS_PORT_TYPE_MIDI, JACKDBUS_PORT_FLAG_OUTPUT))
 382     {
 383       goto fail;
 384     }
 385
 386     if (!create_room_template_port(&room_descriptor, ladish_wkport_playback_left, "Left", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 387     {
 388       goto fail;
 389     }
 390
 391     if (!create_room_template_port(&room_descriptor, ladish_wkport_playback_right, "Right", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 392     {
 393       goto fail;
 394     }
 395
 396     if (!create_room_template_port(&room_descriptor, ladish_wkport_monitor_left, "Monitor Left", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 397     {
 398       goto fail;
 399     }
 400
 401     if (!create_room_template_port(&room_descriptor, ladish_wkport_monitor_right, "Monitor Right", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 402     {
 403       goto fail;
 404     }
 405
 406     if (!create_room_template_port(&room_descriptor, ladish_wkport_midi_playback, "MIDI", JACKDBUS_PORT_TYPE_MIDI, JACKDBUS_PORT_FLAG_INPUT))
 407     {
 408       goto fail;
 409     }
 410
 411     list_add_tail(ladish_room_get_list_node(room_descriptor.room), &g_room_templates);
 412   }
 413
 414   create_router_room_template(router_4x4x2x2_room, "Router 4x4x2x2", 4, 4, 2, 2);
 415   create_router_room_template(router_10x10x4x4_room, "Router 10x10x4x4", 10, 10, 4, 4);
 416   create_router_room_template(router_40x40x16x16_room, "Router 40x40x16x16", 40, 40, 16, 16);
 417
 418   return;
 419
 420 fail:
 421   ladish_room_destroy(room_descriptor.room); /* this will destroy the graph clients and ports as well */
 422 }
 423
 424 void create_room_templates(void)
 425 {
 426   create_builtin_room_templates();
 427 }
 428
 429 void maybe_create_room_templates(void)
 430 {
 431   if (list_empty(&g_room_templates))
 432   {
 433     create_room_templates();
 434   }
 435 }
 436
 437 bool room_templates_init(void)
 438 {
 439   INIT_LIST_HEAD(&g_room_templates);
 440
 441   return true;
 442 }
 443
 444 void room_templates_uninit(void)
 445 {
 446   struct list_head * node_ptr;
 447   ladish_room_handle room;
 448
 449   while (!list_empty(&g_room_templates))
 450   {
 451     node_ptr = g_room_templates.next;
 452     list_del(node_ptr);
 453     room = ladish_room_from_list_node(node_ptr);
 454     ladish_room_destroy(room);
 455   }
 456 }
 457
 458 bool room_templates_enum(void * context, bool (* callback)(void * context, ladish_room_handle room))
 459 {
 460   struct list_head * node_ptr;
 461
 462   maybe_create_room_templates();
 463
 464   list_for_each(node_ptr, &g_room_templates)
 465   {
 466     if (!callback(context, ladish_room_from_list_node(node_ptr)))
 467     {
 468       return false;
 469     }
 470   }
 471
 472   return true;
 473 }
 474
 475 ladish_room_handle find_room_template_by_name(const char * name)
 476 {
 477   ladish_room_handle room;
 478   struct list_head * node_ptr;
 479
 480   maybe_create_room_templates();
 481
 482   list_for_each(node_ptr, &g_room_templates)
 483   {
 484     room = ladish_room_from_list_node(node_ptr);
 485     if (strcmp(ladish_room_get_name(room), name) == 0)
 486     {
 487       return room;
 488     }
 489   }
 490
 491   return NULL;
 492 }
 493
 494 ladish_room_handle find_room_template_by_uuid(const uuid_t uuid_ptr)
 495 {
 496   ladish_room_handle room;
 497   struct list_head * node_ptr;
 498   uuid_t uuid;
 499
 500   maybe_create_room_templates();
 501
 502   list_for_each(node_ptr, &g_room_templates)
 503   {
 504     room = ladish_room_from_list_node(node_ptr);
 505     ladish_room_get_uuid(room, uuid);
 506     if (uuid_compare(uuid, uuid_ptr) == 0)
 507     {
 508       return room;
 509     }
 510   }
 511
 512   return NULL;
 513 }
 514
 515 static void ladish_is_studio_loaded(struct cdbus_method_call * call_ptr)
 516 {
 517   DBusMessageIter iter;
 518   dbus_bool_t is_loaded;
 519
 520   is_loaded = ladish_studio_is_loaded();
 521
 522   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 523   if (call_ptr->reply == NULL)
 524   {
 525     goto fail;
 526   }
 527
 528   dbus_message_iter_init_append(call_ptr->reply, &iter);
 529
 530   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &is_loaded))
 531   {
 532     goto fail_unref;
 533   }
 534
 535   return;
 536
 537 fail_unref:
 538   dbus_message_unref(call_ptr->reply);
 539   call_ptr->reply = NULL;
 540
 541 fail:
 542   log_error("Ran out of memory trying to construct method return");
 543 }
 544
 545 #define array_iter_ptr ((DBusMessageIter *)context)
 546
 547 static bool get_studio_list_callback(void * UNUSED(call_ptr), void * context, const char * studio, uint32_t modtime)
 548 {
 549   DBusMessageIter struct_iter;
 550   DBusMessageIter dict_iter;
 551   bool ret;
 552
 553   ret = false;
 554
 555   if (!dbus_message_iter_open_container(array_iter_ptr, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 556     goto exit;
 557
 558   if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &studio))
 559     goto close_struct;
 560
 561   if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 562     goto close_struct;
 563
 564 /*   if (!maybe_add_dict_entry_string(&dict_iter, "Description", xxx)) */
 565 /*     goto close_dict; */
 566
 567   if (!cdbus_add_dict_entry_uint32(&dict_iter, "Modification Time", modtime))
 568     goto close_dict;
 569
 570   ret = true;
 571
 572 close_dict:
 573   if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 574     ret = false;
 575
 576 close_struct:
 577   if (!dbus_message_iter_close_container(array_iter_ptr, &struct_iter))
 578     ret = false;
 579
 580 exit:
 581   return ret;
 582 }
 583
 584 static void ladish_get_studio_list(struct cdbus_method_call * call_ptr)
 585 {
 586   DBusMessageIter iter, array_iter;
 587
 588   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 589   if (call_ptr->reply == NULL)
 590   {
 591     goto fail;
 592   }
 593
 594   dbus_message_iter_init_append(call_ptr->reply, &iter);
 595
 596   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 597   {
 598     goto fail_unref;
 599   }
 600
 601   if (!ladish_studios_iterate(call_ptr, &array_iter, get_studio_list_callback))
 602   {
 603     dbus_message_iter_close_container(&iter, &array_iter);
 604     if (call_ptr->reply == NULL)
 605       goto fail_unref;
 606
 607     /* studios_iterate or get_studio_list_callback() composed error reply */
 608     return;
 609   }
 610
 611   if (!dbus_message_iter_close_container(&iter, &array_iter))
 612   {
 613     goto fail_unref;
 614   }
 615
 616   return;
 617
 618 fail_unref:
 619   dbus_message_unref(call_ptr->reply);
 620   call_ptr->reply = NULL;
 621
 622 fail:
 623   log_error("Ran out of memory trying to construct method return");
 624 }
 625
 626 static void ladish_load_studio(struct cdbus_method_call * call_ptr)
 627 {
 628   const char * name;
 629   bool autostart;
 630
 631   dbus_error_init(&cdbus_g_dbus_error);
 632
 633   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 634   {
 635     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
 636     dbus_error_free(&cdbus_g_dbus_error);
 637     return;
 638   }
 639
 640   log_info("Load studio request (%s)", name);
 641
 642   if (!conf_get_bool(LADISH_CONF_KEY_DAEMON_STUDIO_AUTOSTART, &autostart))
 643   {
 644     autostart = LADISH_CONF_KEY_DAEMON_STUDIO_AUTOSTART_DEFAULT;
 645   }
 646
 647   if (autostart)
 648   {
 649     log_info("Studio will be autostarted upon load");
 650   }
 651
 652   if (ladish_command_load_studio(call_ptr, ladish_studio_get_cmd_queue(), name, autostart))
 653   {
 654     cdbus_method_return_new_void(call_ptr);
 655   }
 656 }
 657
 658 static void ladish_delete_studio(struct cdbus_method_call * call_ptr)
 659 {
 660   const char * name;
 661
 662   dbus_error_init(&cdbus_g_dbus_error);
 663
 664   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 665   {
 666     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
 667     dbus_error_free(&cdbus_g_dbus_error);
 668     return;
 669   }
 670
 671   if (ladish_studio_delete(call_ptr, name))
 672   {
 673     cdbus_method_return_new_void(call_ptr);
 674   }
 675 }
 676
 677 static void ladish_new_studio(struct cdbus_method_call * call_ptr)
 678 {
 679   const char * name;
 680
 681   dbus_error_init(&cdbus_g_dbus_error);
 682
 683   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 684   {
 685     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
 686     dbus_error_free(&cdbus_g_dbus_error);
 687     return;
 688   }
 689
 690   log_info("New studio request (%s)", name);
 691
 692   if (ladish_command_new_studio(call_ptr, ladish_studio_get_cmd_queue(), name))
 693   {
 694     cdbus_method_return_new_void(call_ptr);
 695   }
 696 }
 697
 698 static void ladish_get_application_list(struct cdbus_method_call * call_ptr)
 699 {
 700   DBusMessageIter iter;
 701   DBusMessageIter array_iter;
 702 #if 0
 703   DBusMessageIter struct_iter;
 704   DBusMessageIter dict_iter;
 705   struct list_head * node_ptr;
 706   struct lash_appdb_entry * entry_ptr;
 707 #endif
 708
 709   log_info("Getting applications list");
 710
 711   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 712   if (call_ptr->reply == NULL)
 713   {
 714     goto fail;
 715   }
 716
 717   dbus_message_iter_init_append(call_ptr->reply, &iter);
 718
 719   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 720   {
 721     goto fail_unref;
 722   }
 723
 724 #if 0
 725   list_for_each(node_ptr, &g_server->appdb)
 726   {
 727     entry_ptr = list_entry(node_ptr, struct lash_appdb_entry, siblings);
 728
 729     if (!dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 730       goto fail_unref;
 731
 732     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, (const void *) &entry_ptr->name))
 733     {
 734       dbus_message_iter_close_container(&iter, &array_iter);
 735       goto fail_unref;
 736     }
 737
 738     if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 739       goto fail_unref;
 740
 741     if (!maybe_add_dict_entry_string(&dict_iter, "GenericName", entry_ptr->generic_name))
 742       goto fail_unref;
 743
 744     if (!maybe_add_dict_entry_string(&dict_iter, "Comment", entry_ptr->comment))
 745       goto fail_unref;
 746
 747     if (!maybe_add_dict_entry_string(&dict_iter, "Icon", entry_ptr->icon))
 748       goto fail_unref;
 749
 750     if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 751       goto fail_unref;
 752
 753     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
 754       goto fail_unref;
 755   }
 756 #endif
 757
 758   if (!dbus_message_iter_close_container(&iter, &array_iter))
 759   {
 760     goto fail_unref;
 761   }
 762
 763   return;
 764
 765 fail_unref:
 766   dbus_message_unref(call_ptr->reply);
 767   call_ptr->reply = NULL;
 768 fail:
 769   return;
 770 }
 771
 772 #define array_iter_ptr ((DBusMessageIter *)context)
 773
 774 bool room_template_list_filler(void * context, ladish_room_handle room)
 775 {
 776   DBusMessageIter struct_iter;
 777   DBusMessageIter dict_iter;
 778   const char * name;
 779
 780   name = ladish_room_get_name(room);
 781
 782   if (!dbus_message_iter_open_container(array_iter_ptr, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 783     return false;
 784
 785   if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &name))
 786     return false;
 787
 788   if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 789     return false;
 790
 791   if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 792     return false;
 793
 794   if (!dbus_message_iter_close_container(array_iter_ptr, &struct_iter))
 795     return false;
 796
 797   return true;
 798 }
 799
 800 #undef array_iter_ptr
 801
 802 static void ladish_get_room_template_list(struct cdbus_method_call * call_ptr)
 803 {
 804   DBusMessageIter iter, array_iter;
 805
 806   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 807   if (call_ptr->reply == NULL)
 808   {
 809     goto fail;
 810   }
 811
 812   dbus_message_iter_init_append(call_ptr->reply, &iter);
 813
 814   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 815   {
 816     goto fail_unref;
 817   }
 818
 819   if (!room_templates_enum(&array_iter, room_template_list_filler))
 820   {
 821     goto fail_unref;
 822   }
 823
 824   if (!dbus_message_iter_close_container(&iter, &array_iter))
 825   {
 826     goto fail_unref;
 827   }
 828
 829   return;
 830
 831 fail_unref:
 832   dbus_message_unref(call_ptr->reply);
 833   call_ptr->reply = NULL;
 834
 835 fail:
 836   log_error("Ran out of memory trying to construct method return");
 837 }
 838
 839 static void ladish_delete_room_template(struct cdbus_method_call * call_ptr)
 840 {
 841   const char * name;
 842
 843   dbus_error_init(&cdbus_g_dbus_error);
 844
 845   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 846   {
 847     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
 848     dbus_error_free(&cdbus_g_dbus_error);
 849     return;
 850   }
 851
 852   log_info("Delete room request (%s)", name);
 853
 854   {
 855     cdbus_method_return_new_void(call_ptr);
 856   }
 857 }
 858
 859 static void ladish_create_room_template(struct cdbus_method_call * call_ptr)
 860 {
 861   const char * name;
 862
 863   dbus_error_init(&cdbus_g_dbus_error);
 864
 865   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 866   {
 867     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
 868     dbus_error_free(&cdbus_g_dbus_error);
 869     return;
 870   }
 871
 872   log_info("New room request (%s)", name);
 873
 874   {
 875     cdbus_method_return_new_void(call_ptr);
 876   }
 877 }
 878
 879 static void ladish_exit(struct cdbus_method_call * call_ptr)
 880 {
 881   log_info("Exit command received through D-Bus");
 882
 883   if (!ladish_command_exit(NULL, ladish_studio_get_cmd_queue()))
 884   { /* if queuing of command failed, force exit anyway,
 885        JACK server will be left started,
 886        but refusing exit command is worse */
 887     g_quit = true;
 888   }
 889
 890   cdbus_method_return_new_void(call_ptr);
 891 }
 892
 893 void emit_studio_appeared(void)
 894 {
 895   cdbus_signal_emit(cdbus_g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "StudioAppeared", "");
 896 }
 897
 898 void emit_studio_disappeared(void)
 899 {
 900   cdbus_signal_emit(cdbus_g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "StudioDisappeared", "");
 901 }
 902
 903 void emit_queue_execution_halted(void)
 904 {
 905   cdbus_signal_emit(cdbus_g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "QueueExecutionHalted", "");
 906 }
 907
 908 void emit_clean_exit(void)
 909 {
 910   cdbus_signal_emit(cdbus_g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "CleanExit", "");
 911 }
 912
 913 CDBUS_METHOD_ARGS_BEGIN(IsStudioLoaded, "Check whether studio D-Bus object is present")
 914   CDBUS_METHOD_ARG_DESCRIBE_OUT("present", "b", "Whether studio D-Bus object is present")
 915 CDBUS_METHOD_ARGS_END
 916
 917 CDBUS_METHOD_ARGS_BEGIN(GetStudioList, "Get list of studios")
 918   CDBUS_METHOD_ARG_DESCRIBE_OUT("studio_list", "a(sa{sv})", "List of studios, name and properties")
 919 CDBUS_METHOD_ARGS_END
 920
 921 CDBUS_METHOD_ARGS_BEGIN(NewStudio, "New studio")
 922   CDBUS_METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio, if empty name will be generated")
 923 CDBUS_METHOD_ARGS_END
 924
 925 CDBUS_METHOD_ARGS_BEGIN(LoadStudio, "Load studio")
 926   CDBUS_METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio to load")
 927   CDBUS_METHOD_ARG_DESCRIBE_IN("options", "a{sv}", "Load options")
 928 CDBUS_METHOD_ARGS_END
 929
 930 CDBUS_METHOD_ARGS_BEGIN(DeleteStudio, "Delete studio")
 931   CDBUS_METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio to delete")
 932 CDBUS_METHOD_ARGS_END
 933
 934 CDBUS_METHOD_ARGS_BEGIN(GetApplicationList, "Get list of applications that can be launched")
 935   CDBUS_METHOD_ARG_DESCRIBE_OUT("applications", "a(sa{sv})", "List of applications, name and properties")
 936 CDBUS_METHOD_ARGS_END
 937
 938 CDBUS_METHOD_ARGS_BEGIN(GetRoomTemplateList, "Get list of room templates")
 939   CDBUS_METHOD_ARG_DESCRIBE_OUT("room_template_list", "a(sa{sv})", "List of room templates (name and properties)")
 940 CDBUS_METHOD_ARGS_END
 941
 942 CDBUS_METHOD_ARGS_BEGIN(CreateRoomTemplate, "New room template")
 943   CDBUS_METHOD_ARG_DESCRIBE_IN("room_template name", "s", "Name of the room template")
 944 CDBUS_METHOD_ARGS_END
 945
 946 CDBUS_METHOD_ARGS_BEGIN(DeleteRoomTemplate, "Delete room template")
 947   CDBUS_METHOD_ARG_DESCRIBE_IN("room_template_name", "s", "Name of room template to delete")
 948 CDBUS_METHOD_ARGS_END
 949
 950 CDBUS_METHOD_ARGS_BEGIN(Exit, "Tell ladish D-Bus service to exit")
 951 CDBUS_METHOD_ARGS_END
 952
 953 CDBUS_METHODS_BEGIN
 954   CDBUS_METHOD_DESCRIBE(IsStudioLoaded, ladish_is_studio_loaded)
 955   CDBUS_METHOD_DESCRIBE(GetStudioList, ladish_get_studio_list)
 956   CDBUS_METHOD_DESCRIBE(NewStudio, ladish_new_studio)
 957   CDBUS_METHOD_DESCRIBE(LoadStudio, ladish_load_studio)
 958   CDBUS_METHOD_DESCRIBE(DeleteStudio, ladish_delete_studio)
 959   CDBUS_METHOD_DESCRIBE(GetApplicationList, ladish_get_application_list)
 960   CDBUS_METHOD_DESCRIBE(GetRoomTemplateList, ladish_get_room_template_list)
 961   CDBUS_METHOD_DESCRIBE(CreateRoomTemplate, ladish_create_room_template)
 962   CDBUS_METHOD_DESCRIBE(DeleteRoomTemplate, ladish_delete_room_template)
 963   CDBUS_METHOD_DESCRIBE(Exit, ladish_exit)
 964 CDBUS_METHODS_END
 965
 966 CDBUS_SIGNAL_ARGS_BEGIN(StudioAppeared, "Studio D-Bus object appeared")
 967 CDBUS_SIGNAL_ARGS_END
 968
 969 CDBUS_SIGNAL_ARGS_BEGIN(StudioDisappeared, "Studio D-Bus object disappeared")
 970 CDBUS_SIGNAL_ARGS_END
 971
 972 CDBUS_SIGNAL_ARGS_BEGIN(QueueExecutionHalted, "Queue execution is halted because of error")
 973 CDBUS_SIGNAL_ARGS_END
 974
 975 CDBUS_SIGNAL_ARGS_BEGIN(CleanExit, "Exit was requested")
 976 CDBUS_SIGNAL_ARGS_END
 977
 978 CDBUS_SIGNALS_BEGIN
 979   CDBUS_SIGNAL_DESCRIBE(StudioAppeared)
 980   CDBUS_SIGNAL_DESCRIBE(StudioDisappeared)
 981   CDBUS_SIGNAL_DESCRIBE(QueueExecutionHalted)
 982   CDBUS_SIGNAL_DESCRIBE(CleanExit)
 983 CDBUS_SIGNALS_END
 984
 985 /*
 986  * Interface description.
 987  */
 988
 989 CDBUS_INTERFACE_DEFAULT_HANDLER_METHODS_AND_SIGNALS(g_lashd_interface_control, INTERFACE_NAME)