daemon/studio.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains part of the studio singleton object implementation
   9  * Other parts are in the other studio*.c files in same directory.
  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 <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33 #include <dirent.h>
  34
  35 #include "studio_internal.h"
  36 #include "../dbus_constants.h"
  37 #include "control.h"
  38 #include "../common/catdup.h"
  39 #include "../common/dirhelpers.h"
  40 #include "graph_dict.h"
  41 #include "escape.h"
  42 #include "studio.h"
  43 #include "../proxies/notify_proxy.h"
  44
  45 #define STUDIOS_DIR "/studios/"
  46 char * g_studios_dir;
  47
  48 struct studio g_studio;
  49
  50 bool ladish_studio_name_generate(char ** name_ptr)
  51 {
  52   time_t now;
  53   char timestamp_str[26];
  54   char * name;
  55
  56   time(&now);
  57   //ctime_r(&now, timestamp_str);
  58   //timestamp_str[24] = 0;
  59   snprintf(timestamp_str, sizeof(timestamp_str), "%llu", (unsigned long long)now);
  60
  61   name = catdup("Studio ", timestamp_str);
  62   if (name == NULL)
  63   {
  64     log_error("catdup failed to create studio name");
  65     return false;
  66   }
  67
  68   *name_ptr = name;
  69   return true;
  70 }
  71
  72 bool ladish_studio_show(void)
  73 {
  74   dbus_object_path object;
  75
  76   ASSERT(g_studio.name != NULL);
  77   ASSERT(!g_studio.announced);
  78
  79   object = dbus_object_path_new(
  80     STUDIO_OBJECT_PATH,
  81     &g_interface_studio, &g_studio,
  82     &g_interface_patchbay, ladish_graph_get_dbus_context(g_studio.studio_graph),
  83     &g_iface_graph_dict, g_studio.studio_graph,
  84     &g_iface_app_supervisor, g_studio.app_supervisor,
  85     NULL);
  86   if (object == NULL)
  87   {
  88     log_error("dbus_object_path_new() failed");
  89     return false;
  90   }
  91
  92   if (!dbus_object_path_register(g_dbus_connection, object))
  93   {
  94     log_error("object_path_register() failed");
  95     dbus_object_path_destroy(g_dbus_connection, object);
  96     return false;
  97   }
  98
  99   log_info("Studio D-Bus object created. \"%s\"", g_studio.name);
 100
 101   g_studio.dbus_object = object;
 102
 103   emit_studio_appeared();
 104
 105   return true;
 106 }
 107
 108 void ladish_studio_announce(void)
 109 {
 110   ASSERT(!g_studio.announced);
 111
 112   /* notify the user that studio started successfully, but dont lie when jack was started externally */
 113   if (!g_studio.automatic)
 114   {
 115     ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio loaded", NULL);
 116   }
 117
 118   g_studio.announced = true;
 119 }
 120
 121 bool ladish_studio_publish(void)
 122 {
 123   if (!ladish_studio_show())
 124   {
 125     return false;
 126   }
 127
 128   ladish_studio_announce();
 129   return true;
 130 }
 131
 132 void ladish_studio_clear(void)
 133 {
 134   ladish_graph_dump(g_studio.studio_graph);
 135   ladish_graph_dump(g_studio.jack_graph);
 136
 137   /* remove rooms that own clients in studio graph before clearing it */
 138   ladish_studio_remove_all_rooms();
 139
 140   ladish_graph_clear(g_studio.studio_graph, NULL);
 141   ladish_graph_clear(g_studio.jack_graph, NULL);
 142
 143   ladish_studio_jack_conf_clear();
 144
 145   g_studio.modified = false;
 146   g_studio.persisted = false;
 147
 148   ladish_app_supervisor_clear(g_studio.app_supervisor);
 149
 150   if (g_studio.dbus_object != NULL)
 151   {
 152     dbus_object_path_destroy(g_dbus_connection, g_studio.dbus_object);
 153     g_studio.dbus_object = NULL;
 154     emit_studio_disappeared();
 155   }
 156
 157   if (g_studio.announced)
 158   {
 159     ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio unloaded", NULL);
 160     g_studio.announced = false;
 161   }
 162
 163   if (g_studio.name != NULL)
 164   {
 165     free(g_studio.name);
 166     g_studio.name = NULL;
 167   }
 168
 169   if (g_studio.filename != NULL)
 170   {
 171     free(g_studio.filename);
 172     g_studio.filename = NULL;
 173   }
 174 }
 175
 176 void ladish_studio_emit_started(void)
 177 {
 178   dbus_signal_emit(g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioStarted", "");
 179 }
 180
 181 void ladish_studio_emit_crashed(void)
 182 {
 183   dbus_signal_emit(g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioCrashed", "");
 184 }
 185
 186 void ladish_studio_emit_stopped(void)
 187 {
 188   dbus_signal_emit(g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioStopped", "");
 189 }
 190
 191 static bool ladish_studio_fill_room_info(DBusMessageIter * iter_ptr, ladish_room_handle room)
 192 {
 193   DBusMessageIter dict_iter;
 194   const char * name;
 195   uuid_t template_uuid;
 196   ladish_room_handle template;
 197   const char * template_name;
 198   const char * opath;
 199
 200   name = ladish_room_get_name(room);
 201   opath = ladish_room_get_opath(room);
 202
 203   if (!ladish_room_get_template_uuid(room, template_uuid))
 204   {
 205     template = NULL;
 206     template_name = NULL;
 207   }
 208   else
 209   {
 210     template = find_room_template_by_uuid(template_uuid);
 211     if (template != NULL)
 212     {
 213       template_name = ladish_room_get_name(template);
 214     }
 215     else
 216     {
 217       template_name = NULL;
 218     }
 219   }
 220
 221   if (!dbus_message_iter_append_basic(iter_ptr, DBUS_TYPE_STRING, &opath))
 222   {
 223     log_error("dbus_message_iter_append_basic() failed.");
 224     return false;
 225   }
 226
 227   if (!dbus_message_iter_open_container(iter_ptr, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 228   {
 229     log_error("dbus_message_iter_open_container() failed.");
 230     return false;
 231   }
 232
 233   if (!dbus_maybe_add_dict_entry_string(&dict_iter, "template", template_name))
 234   {
 235     log_error("dbus_maybe_add_dict_entry_string() failed.");
 236     return false;
 237   }
 238
 239   if (!dbus_maybe_add_dict_entry_string(&dict_iter, "name", name))
 240   {
 241     log_error("dbus_maybe_add_dict_entry_string() failed.");
 242     return false;
 243   }
 244
 245   if (!dbus_message_iter_close_container(iter_ptr, &dict_iter))
 246   {
 247     log_error("dbus_message_iter_close_container() failed.");
 248     return false;
 249   }
 250
 251   return true;
 252 }
 253
 254 static void ladish_studio_emit_room_appeared(ladish_room_handle room)
 255 {
 256   DBusMessage * message_ptr;
 257   DBusMessageIter iter;
 258
 259   message_ptr = dbus_message_new_signal(STUDIO_OBJECT_PATH, IFACE_STUDIO, "RoomAppeared");
 260   if (message_ptr == NULL)
 261   {
 262     log_error("dbus_message_new_signal() failed.");
 263     return;
 264   }
 265
 266   dbus_message_iter_init_append(message_ptr, &iter);
 267
 268   if (ladish_studio_fill_room_info(&iter, room))
 269   {
 270     dbus_signal_send(g_dbus_connection, message_ptr);
 271   }
 272
 273   dbus_message_unref(message_ptr);
 274 }
 275
 276 void ladish_studio_emit_room_disappeared(ladish_room_handle room)
 277 {
 278   DBusMessage * message_ptr;
 279   DBusMessageIter iter;
 280
 281   message_ptr = dbus_message_new_signal(STUDIO_OBJECT_PATH, IFACE_STUDIO, "RoomDisappeared");
 282   if (message_ptr == NULL)
 283   {
 284     log_error("dbus_message_new_signal() failed.");
 285     return;
 286   }
 287
 288   dbus_message_iter_init_append(message_ptr, &iter);
 289
 290   if (ladish_studio_fill_room_info(&iter, room))
 291   {
 292     dbus_signal_send(g_dbus_connection, message_ptr);
 293   }
 294
 295   dbus_message_unref(message_ptr);
 296 }
 297
 298 void ladish_studio_room_appeared(ladish_room_handle room)
 299 {
 300   log_info("Room \"%s\" appeared", ladish_room_get_name(room));
 301   list_add_tail(ladish_room_get_list_node(room), &g_studio.rooms);
 302   ladish_studio_emit_room_appeared(room);
 303 }
 304
 305 void ladish_studio_room_disappeared(ladish_room_handle room)
 306 {
 307   log_info("Room \"%s\" disappeared", ladish_room_get_name(room));
 308   list_del(ladish_room_get_list_node(room));
 309   ladish_studio_emit_room_disappeared(room);
 310 }
 311
 312 bool
 313 ladish_studio_set_graph_connection_handlers(
 314   void * context,
 315   ladish_graph_handle graph,
 316   ladish_app_supervisor_handle app_supervisor)
 317 {
 318   ladish_virtualizer_set_graph_connection_handlers(context, graph);
 319   return true;                  /* iterate all graphs */
 320 }
 321
 322 void ladish_studio_on_event_jack_started(void)
 323 {
 324   if (!ladish_studio_fetch_jack_settings())
 325   {
 326     log_error("studio_fetch_jack_settings() failed.");
 327
 328     return;
 329   }
 330
 331   log_info("jack conf successfully retrieved");
 332   g_studio.jack_conf_valid = true;
 333
 334   if (!graph_proxy_create(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, false, &g_studio.jack_graph_proxy))
 335   {
 336     log_error("graph_proxy_create() failed for jackdbus");
 337   }
 338   else
 339   {
 340     if (!ladish_virtualizer_create(g_studio.jack_graph_proxy, g_studio.jack_graph, &g_studio.virtualizer))
 341     {
 342       log_error("ladish_virtualizer_create() failed.");
 343     }
 344     else
 345     {
 346       ladish_studio_iterate_virtual_graphs(g_studio.virtualizer, ladish_studio_set_graph_connection_handlers);
 347     }
 348
 349     if (!graph_proxy_activate(g_studio.jack_graph_proxy))
 350     {
 351       log_error("graph_proxy_activate() failed.");
 352     }
 353   }
 354
 355   ladish_app_supervisor_autorun(g_studio.app_supervisor);
 356
 357   ladish_studio_emit_started();
 358
 359   /* notify the user that studio started successfully, but dont lie when jack was started externally */
 360   if (!g_studio.automatic)
 361   {
 362     ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio started", NULL);
 363   }
 364 }
 365
 366 static void ladish_studio_on_jack_stopped_internal(void)
 367 {
 368   if (g_studio.virtualizer)
 369   {
 370     ladish_virtualizer_destroy(g_studio.virtualizer);
 371     g_studio.virtualizer = NULL;
 372   }
 373
 374   if (g_studio.jack_graph_proxy)
 375   {
 376     graph_proxy_destroy(g_studio.jack_graph_proxy);
 377     g_studio.jack_graph_proxy = NULL;
 378   }
 379 }
 380
 381 void ladish_studio_on_event_jack_stopped(void)
 382 {
 383   ladish_studio_emit_stopped();
 384   ladish_studio_on_jack_stopped_internal();
 385   ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio stopped", NULL);
 386 }
 387
 388 void ladish_studio_handle_unexpected_jack_server_stop(void)
 389 {
 390   ladish_studio_emit_crashed();
 391   ladish_studio_on_jack_stopped_internal();
 392
 393   /* TODO: if user wants, restart jack server and reconnect all jack apps to it */
 394 }
 395
 396 static bool ladish_studio_hide_vgraph_non_virtual(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 397 {
 398   ladish_graph_hide_non_virtual(graph);
 399   return true;                  /* iterate all vgraphs */
 400 }
 401
 402 void ladish_studio_run(void)
 403 {
 404   bool state;
 405
 406   ladish_cqueue_run(&g_studio.cmd_queue);
 407   if (g_quit)
 408   { /* if quit is requested, don't bother to process external events */
 409     return;
 410   }
 411
 412   if (ladish_environment_consume_change(&g_studio.env_store, ladish_environment_jack_server_started, &state))
 413   {
 414     ladish_cqueue_clear(&g_studio.cmd_queue);
 415
 416     if (state)
 417     {
 418       ladish_environment_ignore(&g_studio.env_store, ladish_environment_jack_server_present);
 419
 420       if (g_studio.jack_graph_proxy != NULL)
 421       {
 422         log_error("Ignoring \"JACK started\" notification because it is already known that JACK is currently started.");
 423         return;
 424       }
 425
 426       /* Automatic studio creation on JACK server start */
 427       if (g_studio.dbus_object == NULL)
 428       {
 429         ASSERT(g_studio.name == NULL);
 430         if (!ladish_studio_name_generate(&g_studio.name))
 431         {
 432           log_error("studio_name_generate() failed.");
 433           return;
 434         }
 435
 436         g_studio.automatic = true;
 437
 438         ladish_studio_publish();
 439       }
 440
 441       ladish_studio_on_event_jack_started();
 442
 443       if (g_studio.automatic)
 444       {
 445         ladish_notify_simple(
 446           LADISH_NOTIFY_URGENCY_NORMAL,
 447           "Automatic studio created",
 448           "JACK server is started not by ladish daemon and there is no loaded studio, so a new studio is created and marked as started.");
 449       }
 450     }
 451     else
 452     {
 453       /* JACK stopped but this was not expected. When expected.
 454        * the change will be consumed by the run method of the studio stop command */
 455
 456       if (g_studio.jack_graph_proxy == NULL)
 457       {
 458         log_error("Ignoring \"JACK stopped\" notification because it is already known that JACK is currently stopped.");
 459         return;
 460       }
 461
 462       if (g_studio.automatic)
 463       {
 464         log_info("Unloading automatic studio.");
 465         ladish_command_unload_studio(NULL, &g_studio.cmd_queue);
 466
 467         ladish_studio_on_event_jack_stopped();
 468         return;
 469       }
 470
 471       log_error("JACK stopped unexpectedly.");
 472       log_error("Save your work, then unload and reload the studio.");
 473       ladish_notify_simple(
 474         LADISH_NOTIFY_URGENCY_HIGH,
 475         "Studio crashed",
 476         "JACK stopped unexpectedly.\n\n"
 477         "Save your work, then unload and reload the studio.");
 478       ladish_studio_handle_unexpected_jack_server_stop();
 479     }
 480   }
 481
 482   if (ladish_environment_consume_change(&g_studio.env_store, ladish_environment_jack_server_present, &state))
 483   {
 484     if (g_studio.jack_graph_proxy != NULL)
 485     {
 486       ladish_cqueue_clear(&g_studio.cmd_queue);
 487
 488       /* jack was started, this probably means that jackdbus has crashed */
 489       log_error("JACK disappeared unexpectedly. Maybe it crashed.");
 490       log_error("Save your work, then unload and reload the studio.");
 491       ladish_notify_simple(
 492         LADISH_NOTIFY_URGENCY_HIGH,
 493         "Studio crashed",
 494         "JACK disappeared unexpectedly. Maybe it crashed.\n\n"
 495         "Save your work, then unload and reload the studio.");
 496       ladish_environment_reset_stealth(&g_studio.env_store, ladish_environment_jack_server_started);
 497
 498       ladish_studio_iterate_virtual_graphs(NULL, ladish_studio_hide_vgraph_non_virtual);
 499
 500       ladish_studio_handle_unexpected_jack_server_stop();
 501     }
 502   }
 503
 504   ladish_environment_assert_consumed(&g_studio.env_store);
 505 }
 506
 507 static void ladish_studio_on_jack_server_started(void)
 508 {
 509   log_info("JACK server start detected.");
 510   ladish_environment_set(&g_studio.env_store, ladish_environment_jack_server_started);
 511 }
 512
 513 static void ladish_studio_on_jack_server_stopped(void)
 514 {
 515   log_info("JACK server stop detected.");
 516   ladish_environment_reset(&g_studio.env_store, ladish_environment_jack_server_started);
 517 }
 518
 519 static void ladish_studio_on_jack_server_appeared(void)
 520 {
 521   log_info("JACK controller appeared.");
 522   ladish_environment_set(&g_studio.env_store, ladish_environment_jack_server_present);
 523 }
 524
 525 static void ladish_studio_on_jack_server_disappeared(void)
 526 {
 527   log_info("JACK controller disappeared.");
 528   ladish_environment_reset(&g_studio.env_store, ladish_environment_jack_server_present);
 529 }
 530
 531 bool ladish_studio_init(void)
 532 {
 533   log_info("studio object construct");
 534
 535   g_studios_dir = catdup(g_base_dir, STUDIOS_DIR);
 536   if (g_studios_dir == NULL)
 537   {
 538     log_error("catdup failed for '%s' and '%s'", g_base_dir, STUDIOS_DIR);
 539     goto fail;
 540   }
 541
 542   if (!ensure_dir_exist(g_studios_dir, 0700))
 543   {
 544     goto free_studios_dir;
 545   }
 546
 547   INIT_LIST_HEAD(&g_studio.all_connections);
 548   INIT_LIST_HEAD(&g_studio.all_ports);
 549   INIT_LIST_HEAD(&g_studio.all_clients);
 550   INIT_LIST_HEAD(&g_studio.jack_connections);
 551   INIT_LIST_HEAD(&g_studio.jack_ports);
 552   INIT_LIST_HEAD(&g_studio.jack_clients);
 553   INIT_LIST_HEAD(&g_studio.rooms);
 554   INIT_LIST_HEAD(&g_studio.clients);
 555   INIT_LIST_HEAD(&g_studio.ports);
 556
 557   INIT_LIST_HEAD(&g_studio.jack_conf);
 558   INIT_LIST_HEAD(&g_studio.jack_params);
 559
 560   g_studio.dbus_object = NULL;
 561   g_studio.announced = false;
 562   g_studio.name = NULL;
 563   g_studio.filename = NULL;
 564
 565   g_studio.room_count = 0;
 566
 567   if (!ladish_graph_create(&g_studio.jack_graph, NULL))
 568   {
 569     log_error("ladish_graph_create() failed to create jack graph object.");
 570     goto free_studios_dir;
 571   }
 572
 573   if (!ladish_graph_create(&g_studio.studio_graph, STUDIO_OBJECT_PATH))
 574   {
 575     log_error("ladish_graph_create() failed to create studio graph object.");
 576     goto jack_graph_destroy;
 577   }
 578
 579   if (!ladish_app_supervisor_create(&g_studio.app_supervisor, STUDIO_OBJECT_PATH, "studio", g_studio.studio_graph, ladish_virtualizer_rename_app))
 580   {
 581     log_error("ladish_app_supervisor_create() failed.");
 582     goto studio_graph_destroy;
 583   }
 584
 585   ladish_cqueue_init(&g_studio.cmd_queue);
 586   ladish_environment_init(&g_studio.env_store);
 587
 588   if (!jack_proxy_init(
 589         ladish_studio_on_jack_server_started,
 590         ladish_studio_on_jack_server_stopped,
 591         ladish_studio_on_jack_server_appeared,
 592         ladish_studio_on_jack_server_disappeared))
 593   {
 594     log_error("jack_proxy_init() failed.");
 595     goto app_supervisor_destroy;
 596   }
 597
 598   return true;
 599
 600 app_supervisor_destroy:
 601   ladish_app_supervisor_destroy(g_studio.app_supervisor);
 602 studio_graph_destroy:
 603   ladish_graph_destroy(g_studio.studio_graph);
 604 jack_graph_destroy:
 605   ladish_graph_destroy(g_studio.jack_graph);
 606 free_studios_dir:
 607   free(g_studios_dir);
 608 fail:
 609   return false;
 610 }
 611
 612 void ladish_studio_uninit(void)
 613 {
 614   log_info("studio_uninit()");
 615
 616   jack_proxy_uninit();
 617
 618   ladish_cqueue_clear(&g_studio.cmd_queue);
 619
 620   ladish_graph_destroy(g_studio.studio_graph);
 621   ladish_graph_destroy(g_studio.jack_graph);
 622
 623   free(g_studios_dir);
 624
 625   log_info("studio object destroy");
 626 }
 627
 628 struct on_child_exit_context
 629 {
 630   pid_t pid;
 631   bool found;
 632 };
 633
 634 #define child_exit_context_ptr ((struct on_child_exit_context *)context)
 635
 636 static
 637 bool
 638 ladish_studio_on_child_exit_callback(
 639   void * context,
 640   ladish_graph_handle graph,
 641   ladish_app_supervisor_handle app_supervisor)
 642 {
 643   child_exit_context_ptr->found = ladish_app_supervisor_child_exit(app_supervisor, child_exit_context_ptr->pid);
 644   /* if child is found, return false - it will cause iteration to stop */
 645   /* if child is not found, return true - it will cause next supervisor to be checked */
 646   return !child_exit_context_ptr->found;
 647 }
 648
 649 #undef child_exit_context_ptr
 650
 651 void ladish_studio_on_child_exit(pid_t pid)
 652 {
 653   struct on_child_exit_context context;
 654
 655   context.pid = pid;
 656   context.found = false;
 657
 658   ladish_studio_iterate_virtual_graphs(&context, ladish_studio_on_child_exit_callback);
 659
 660   if (!context.found)
 661   {
 662     log_error("unknown child exit detected. pid is %llu", (unsigned long long)pid);
 663   }
 664 }
 665
 666 bool ladish_studio_is_loaded(void)
 667 {
 668   return g_studio.dbus_object != NULL && g_studio.announced;
 669 }
 670
 671 bool ladish_studio_is_started(void)
 672 {
 673   return ladish_environment_get(&g_studio.env_store, ladish_environment_jack_server_started);
 674 }
 675
 676 bool ladish_studio_compose_filename(const char * name, char ** filename_ptr_ptr, char ** backup_filename_ptr_ptr)
 677 {
 678   size_t len_dir;
 679   char * p;
 680   const char * src;
 681   char * filename_ptr;
 682   char * backup_filename_ptr = NULL;
 683
 684   len_dir = strlen(g_studios_dir);
 685
 686   filename_ptr = malloc(len_dir + 1 + strlen(name) * 3 + 4 + 1);
 687   if (filename_ptr == NULL)
 688   {
 689     log_error("malloc failed to allocate memory for studio file path");
 690     return false;
 691   }
 692
 693   if (backup_filename_ptr_ptr != NULL)
 694   {
 695     backup_filename_ptr = malloc(len_dir + 1 + strlen(name) * 3 + 4 + 4 + 1);
 696     if (backup_filename_ptr == NULL)
 697     {
 698       log_error("malloc failed to allocate memory for studio backup file path");
 699       free(filename_ptr);
 700       return false;
 701     }
 702   }
 703
 704   p = filename_ptr;
 705   memcpy(p, g_studios_dir, len_dir);
 706   p += len_dir;
 707
 708   *p++ = '/';
 709
 710   src = name;
 711   escape(&src, &p);
 712   strcpy(p, ".xml");
 713
 714   *filename_ptr_ptr = filename_ptr;
 715
 716   if (backup_filename_ptr_ptr != NULL)
 717   {
 718     strcpy(backup_filename_ptr, filename_ptr);
 719     strcat(backup_filename_ptr, ".bak");
 720     *backup_filename_ptr_ptr = backup_filename_ptr;
 721   }
 722
 723   return true;
 724 }
 725
 726 struct ladish_cqueue * ladish_studio_get_cmd_queue(void)
 727 {
 728   return &g_studio.cmd_queue;
 729 }
 730
 731 ladish_virtualizer_handle ladish_studio_get_virtualizer(void)
 732 {
 733   return g_studio.virtualizer;
 734 }
 735
 736 ladish_graph_handle ladish_studio_get_jack_graph(void)
 737 {
 738   return g_studio.jack_graph;
 739 }
 740
 741 ladish_graph_handle ladish_studio_get_studio_graph(void)
 742 {
 743   return g_studio.studio_graph;
 744 }
 745
 746 ladish_app_supervisor_handle ladish_studio_get_studio_app_supervisor(void)
 747 {
 748   return g_studio.app_supervisor;
 749 }
 750
 751 struct ladish_studio_app_supervisor_match_context
 752 {
 753   const char * opath;
 754   ladish_app_supervisor_handle supervisor;
 755 };
 756
 757 #define iterate_context_ptr ((struct ladish_studio_app_supervisor_match_context *)context)
 758
 759 static bool ladish_studio_app_supervisor_match(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 760 {
 761   ASSERT(strcmp(ladish_app_supervisor_get_opath(app_supervisor), ladish_graph_get_opath(graph)) == 0);
 762   if (strcmp(ladish_app_supervisor_get_opath(app_supervisor), iterate_context_ptr->opath) == 0)
 763   {
 764     ASSERT(iterate_context_ptr->supervisor == NULL);
 765     iterate_context_ptr->supervisor = app_supervisor;
 766     return false;               /* stop iteration */
 767   }
 768
 769   return true;                  /* continue iteration */
 770 }
 771
 772 #undef iterate_context_ptr
 773
 774 ladish_app_supervisor_handle ladish_studio_find_app_supervisor(const char * opath)
 775 {
 776   struct ladish_studio_app_supervisor_match_context ctx;
 777
 778   ctx.opath = opath;
 779   ctx.supervisor = NULL;
 780   ladish_studio_iterate_virtual_graphs(&ctx, ladish_studio_app_supervisor_match);
 781   return ctx.supervisor;
 782 }
 783
 784 bool ladish_studios_iterate(void * call_ptr, void * context, bool (* callback)(void * call_ptr, void * context, const char * studio, uint32_t modtime))
 785 {
 786   DIR * dir;
 787   struct dirent * dentry;
 788   size_t len;
 789   struct stat st;
 790   char * path;
 791   char * name;
 792
 793   dir = opendir(g_studios_dir);
 794   if (dir == NULL)
 795   {
 796     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot open directory '%s': %d (%s)", g_studios_dir, errno, strerror(errno));
 797     return false;
 798   }
 799
 800   while ((dentry = readdir(dir)) != NULL)
 801   {
 802     len = strlen(dentry->d_name);
 803     if (len <= 4 || strcmp(dentry->d_name + (len - 4), ".xml") != 0)
 804       continue;
 805
 806     path = catdup(g_studios_dir, dentry->d_name);
 807     if (path == NULL)
 808     {
 809       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "catdup() failed");
 810       return false;
 811     }
 812
 813     if (stat(path, &st) != 0)
 814     {
 815       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "failed to stat '%s': %d (%s)", path, errno, strerror(errno));
 816       free(path);
 817       return false;
 818     }
 819
 820     free(path);
 821
 822     if (!S_ISREG(st.st_mode))
 823     {
 824       //log_info("Ignoring direntry that is not regular file. Mode is %07o", st.st_mode);
 825       continue;
 826     }
 827
 828     name = malloc(len - 4 + 1);
 829     if (name == NULL)
 830     {
 831       log_error("malloc() failed.");
 832       closedir(dir);
 833       return false;
 834     }
 835
 836     name[unescape(dentry->d_name, len - 4, name)] = 0;
 837     //log_info("name = '%s'", name);
 838
 839     if (!callback(call_ptr, context, name, st.st_mtime))
 840     {
 841       free(name);
 842       closedir(dir);
 843       return false;
 844     }
 845
 846     free(name);
 847   }
 848
 849   closedir(dir);
 850   return true;
 851 }
 852
 853 bool ladish_studio_delete(void * call_ptr, const char * studio_name)
 854 {
 855   char * filename;
 856   char * bak_filename;
 857   struct stat st;
 858   bool ret;
 859
 860   ret = false;
 861
 862   if (!ladish_studio_compose_filename(studio_name, &filename, &bak_filename))
 863   {
 864     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "failed to compose studio filename");
 865     goto exit;
 866   }
 867
 868   log_info("Deleting studio ('%s')", filename);
 869
 870   if (unlink(filename) != 0)
 871   {
 872     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "unlink(%s) failed: %d (%s)", filename, errno, strerror(errno));
 873     goto free;
 874   }
 875
 876   /* try to delete the backup file */
 877   if (stat(bak_filename, &st) == 0)
 878   {
 879     if (unlink(bak_filename) != 0)
 880     {
 881       /* failing to delete backup file will not case delete command failure */
 882       log_error("unlink(%s) failed: %d (%s)", bak_filename, errno, strerror(errno));
 883     }
 884   }
 885
 886   ret = true;
 887
 888 free:
 889   free(filename);
 890   free(bak_filename);
 891 exit:
 892   return ret;
 893 }
 894
 895 bool
 896 ladish_studio_iterate_virtual_graphs(
 897   void * context,
 898   bool (* callback)(
 899     void * context,
 900     ladish_graph_handle graph,
 901     ladish_app_supervisor_handle app_supervisor))
 902 {
 903   struct list_head * node_ptr;
 904   ladish_room_handle room;
 905   ladish_app_supervisor_handle room_app_supervisor;
 906   ladish_graph_handle room_graph;
 907
 908   if (!callback(context, g_studio.studio_graph, g_studio.app_supervisor))
 909   {
 910     return false;
 911   }
 912
 913   list_for_each(node_ptr, &g_studio.rooms)
 914   {
 915     room = ladish_room_from_list_node(node_ptr);
 916     room_app_supervisor = ladish_room_get_app_supervisor(room);
 917     ASSERT(room_app_supervisor != NULL);
 918     room_graph = ladish_room_get_graph(room);
 919
 920     if (!callback(context, room_graph, room_app_supervisor))
 921     {
 922       return false;
 923     }
 924   }
 925
 926   return true;
 927 }
 928
 929 bool
 930 ladish_studio_iterate_rooms(
 931   void * context,
 932   bool (* callback)(
 933     void * context,
 934     ladish_room_handle room))
 935 {
 936   struct list_head * node_ptr;
 937   ladish_room_handle room;
 938
 939   list_for_each(node_ptr, &g_studio.rooms)
 940   {
 941     room = ladish_room_from_list_node(node_ptr);
 942     if (!callback(context, room))
 943     {
 944       return false;
 945     }
 946   }
 947
 948   return true;
 949 }
 950
 951 bool ladish_studio_has_rooms(void)
 952 {
 953   return !list_empty(&g_studio.rooms);
 954 }
 955
 956 static bool ladish_studio_stop_app_supervisor(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 957 {
 958   ladish_app_supervisor_stop(app_supervisor);
 959   return true;                  /* iterate all supervisors */
 960 }
 961
 962 void ladish_studio_stop_app_supervisors(void)
 963 {
 964   ladish_studio_iterate_virtual_graphs(NULL, ladish_studio_stop_app_supervisor);
 965 }
 966
 967 void ladish_studio_emit_renamed(void)
 968 {
 969   dbus_signal_emit(g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioRenamed", "s", &g_studio.name);
 970 }
 971
 972 unsigned int ladish_studio_get_room_index(void)
 973 {
 974   return ++g_studio.room_count;
 975 }
 976
 977 void ladish_studio_release_room_index(unsigned int index)
 978 {
 979   if (index == g_studio.room_count)
 980   {
 981     g_studio.room_count--;
 982   }
 983 }
 984
 985 void ladish_studio_remove_all_rooms(void)
 986 {
 987   while (!list_empty(&g_studio.rooms))
 988   {
 989     ladish_room_destroy(ladish_room_from_list_node(g_studio.rooms.next));
 990   }
 991 }
 992
 993 ladish_room_handle ladish_studio_find_room_by_uuid(const uuid_t room_uuid_ptr)
 994 {
 995   struct list_head * node_ptr;
 996   ladish_room_handle room;
 997   uuid_t room_uuid;
 998
 999   list_for_each(node_ptr, &g_studio.rooms)
1000   {
1001     room = ladish_room_from_list_node(node_ptr);
1002     ladish_room_get_uuid(room, room_uuid);
1003     if (uuid_compare(room_uuid, room_uuid_ptr) == 0)
1004     {
1005       return room;
1006     }
1007   }
1008
1009   return NULL;
1010 }
1011
1012 bool ladish_studio_check_room_name(const char * room_name)
1013 {
1014   struct list_head * node_ptr;
1015   ladish_room_handle room;
1016
1017   list_for_each(node_ptr, &g_studio.rooms)
1018   {
1019     room = ladish_room_from_list_node(node_ptr);
1020     if (strcmp(ladish_room_get_name(room), room_name) == 0)
1021     {
1022       return true;
1023     }
1024   }
1025
1026   return false;
1027 }
1028
1029 /**********************************************************************************/
1030 /*                                D-Bus methods                                   */
1031 /**********************************************************************************/
1032
1033 static void ladish_studio_dbus_get_name(struct dbus_method_call * call_ptr)
1034 {
1035   method_return_new_single(call_ptr, DBUS_TYPE_STRING, &g_studio.name);
1036 }
1037
1038 static void ladish_studio_dbus_rename(struct dbus_method_call * call_ptr)
1039 {
1040   const char * new_name;
1041   char * new_name_dup;
1042
1043   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &new_name, DBUS_TYPE_INVALID))
1044   {
1045     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1046     dbus_error_free(&g_dbus_error);
1047     return;
1048   }
1049
1050   log_info("Rename studio request (%s)", new_name);
1051
1052   new_name_dup = strdup(new_name);
1053   if (new_name_dup == NULL)
1054   {
1055     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed to allocate new name.");
1056     return;
1057   }
1058
1059   free(g_studio.name);
1060   g_studio.name = new_name_dup;
1061
1062   method_return_new_void(call_ptr);
1063   ladish_studio_emit_renamed();
1064 }
1065
1066 static void ladish_studio_dbus_save(struct dbus_method_call * call_ptr)
1067 {
1068   log_info("Save studio request");
1069
1070   if (ladish_command_save_studio(call_ptr, &g_studio.cmd_queue, g_studio.name))
1071   {
1072     method_return_new_void(call_ptr);
1073   }
1074 }
1075
1076 static void ladish_studio_dbus_save_as(struct dbus_method_call * call_ptr)
1077 {
1078   const char * new_name;
1079
1080   log_info("SaveAs studio request");
1081
1082   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &new_name, DBUS_TYPE_INVALID))
1083   {
1084     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1085     dbus_error_free(&g_dbus_error);
1086     return;
1087   }
1088
1089   if (ladish_command_save_studio(call_ptr, &g_studio.cmd_queue, new_name))
1090   {
1091     method_return_new_void(call_ptr);
1092   }
1093 }
1094
1095 static void ladish_studio_dbus_unload(struct dbus_method_call * call_ptr)
1096 {
1097   log_info("Unload studio request");
1098
1099   if (ladish_command_unload_studio(call_ptr, &g_studio.cmd_queue))
1100   {
1101     method_return_new_void(call_ptr);
1102   }
1103 }
1104
1105 static void ladish_studio_dbus_stop(struct dbus_method_call * call_ptr)
1106 {
1107   log_info("Stop studio request");
1108
1109   g_studio.automatic = false;   /* even if it was automatic, it is not anymore because user knows about it */
1110
1111   if (ladish_command_stop_studio(call_ptr, &g_studio.cmd_queue))
1112   {
1113     method_return_new_void(call_ptr);
1114   }
1115 }
1116
1117 static void ladish_studio_dbus_start(struct dbus_method_call * call_ptr)
1118 {
1119   log_info("Start studio request");
1120
1121   g_studio.automatic = false;   /* even if it was automatic, it is not anymore because user knows about it */
1122
1123   if (ladish_command_start_studio(call_ptr, &g_studio.cmd_queue))
1124   {
1125     method_return_new_void(call_ptr);
1126   }
1127 }
1128
1129 static void ladish_studio_dbus_is_started(struct dbus_method_call * call_ptr)
1130 {
1131   dbus_bool_t started;
1132
1133   started = g_studio.jack_graph_proxy != NULL;
1134
1135   method_return_new_single(call_ptr, DBUS_TYPE_BOOLEAN, &started);
1136 }
1137
1138 static void ladish_studio_dbus_create_room(struct dbus_method_call * call_ptr)
1139 {
1140   const char * room_name;
1141   const char * template_name;
1142
1143   dbus_error_init(&g_dbus_error);
1144
1145   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &room_name, DBUS_TYPE_STRING, &template_name, DBUS_TYPE_INVALID))
1146   {
1147     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1148     dbus_error_free(&g_dbus_error);
1149     return;
1150   }
1151
1152   if (ladish_command_create_room(call_ptr, ladish_studio_get_cmd_queue(), room_name, template_name))
1153   {
1154     method_return_new_void(call_ptr);
1155   }
1156 }
1157
1158 static void ladish_studio_dbus_get_room_list(struct dbus_method_call * call_ptr)
1159 {
1160   DBusMessageIter iter, array_iter;
1161   DBusMessageIter struct_iter;
1162   struct list_head * node_ptr;
1163   ladish_room_handle room;
1164
1165   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
1166   if (call_ptr->reply == NULL)
1167   {
1168     goto fail;
1169   }
1170
1171   dbus_message_iter_init_append(call_ptr->reply, &iter);
1172
1173   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
1174   {
1175     goto fail_unref;
1176   }
1177
1178   list_for_each(node_ptr, &g_studio.rooms)
1179   {
1180     room = ladish_room_from_list_node(node_ptr);
1181
1182     if (!dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
1183       goto fail_unref;
1184
1185     if (!ladish_studio_fill_room_info(&struct_iter, room))
1186       goto fail_unref;
1187
1188     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
1189       goto fail_unref;
1190   }
1191
1192   if (!dbus_message_iter_close_container(&iter, &array_iter))
1193   {
1194     goto fail_unref;
1195   }
1196
1197   return;
1198
1199 fail_unref:
1200   dbus_message_unref(call_ptr->reply);
1201   call_ptr->reply = NULL;
1202
1203 fail:
1204   log_error("Ran out of memory trying to construct method return");
1205 }
1206
1207 static void ladish_studio_dbus_delete_room(struct dbus_method_call * call_ptr)
1208 {
1209   const char * name;
1210
1211   dbus_error_init(&g_dbus_error);
1212
1213   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
1214   {
1215     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1216     dbus_error_free(&g_dbus_error);
1217     return;
1218   }
1219
1220   if (ladish_command_delete_room(call_ptr, ladish_studio_get_cmd_queue(), name))
1221   {
1222     method_return_new_void(call_ptr);
1223   }
1224 }
1225
1226 METHOD_ARGS_BEGIN(GetName, "Get studio name")
1227   METHOD_ARG_DESCRIBE_OUT("studio_name", "s", "Name of studio")
1228 METHOD_ARGS_END
1229
1230 METHOD_ARGS_BEGIN(Rename, "Rename studio")
1231   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "New name")
1232 METHOD_ARGS_END
1233
1234 METHOD_ARGS_BEGIN(Save, "Save studio")
1235 METHOD_ARGS_END
1236
1237 METHOD_ARGS_BEGIN(SaveAs, "SaveAs studio")
1238   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "New name")
1239 METHOD_ARGS_END
1240
1241 METHOD_ARGS_BEGIN(Unload, "Unload studio")
1242 METHOD_ARGS_END
1243
1244 METHOD_ARGS_BEGIN(Start, "Start studio")
1245 METHOD_ARGS_END
1246
1247 METHOD_ARGS_BEGIN(Stop, "Stop studio")
1248 METHOD_ARGS_END
1249
1250 METHOD_ARGS_BEGIN(IsStarted, "Check whether studio is started")
1251   METHOD_ARG_DESCRIBE_OUT("started", "b", "Whether studio is started")
1252 METHOD_ARGS_END
1253
1254 METHOD_ARGS_BEGIN(CreateRoom, "Create new studio room")
1255   METHOD_ARG_DESCRIBE_IN("room_name", "s", "Studio room name")
1256   METHOD_ARG_DESCRIBE_IN("room_template_name", "s", "Room template name")
1257 METHOD_ARGS_END
1258
1259 METHOD_ARGS_BEGIN(GetRoomList, "Get list of rooms in this studio")
1260   METHOD_ARG_DESCRIBE_OUT("room_list", "a(sa{sv})", "List of studio rooms: opaths and properties")
1261 METHOD_ARGS_END
1262
1263 METHOD_ARGS_BEGIN(DeleteRoom, "Delete studio room")
1264   METHOD_ARG_DESCRIBE_IN("room_name", "s", "Name of studio room to delete")
1265 METHOD_ARGS_END
1266
1267 METHODS_BEGIN
1268   METHOD_DESCRIBE(GetName, ladish_studio_dbus_get_name)          /* sync */
1269   METHOD_DESCRIBE(Rename, ladish_studio_dbus_rename)             /* sync */
1270   METHOD_DESCRIBE(Save, ladish_studio_dbus_save)                 /* async */
1271   METHOD_DESCRIBE(SaveAs, ladish_studio_dbus_save_as)            /* async */
1272   METHOD_DESCRIBE(Unload, ladish_studio_dbus_unload)             /* async */
1273   METHOD_DESCRIBE(Start, ladish_studio_dbus_start)               /* async */
1274   METHOD_DESCRIBE(Stop, ladish_studio_dbus_stop)                 /* async */
1275   METHOD_DESCRIBE(IsStarted, ladish_studio_dbus_is_started)      /* sync */
1276   METHOD_DESCRIBE(CreateRoom, ladish_studio_dbus_create_room)    /* async */
1277   METHOD_DESCRIBE(GetRoomList, ladish_studio_dbus_get_room_list) /* sync */
1278   METHOD_DESCRIBE(DeleteRoom, ladish_studio_dbus_delete_room)    /* async */
1279 METHODS_END
1280
1281 SIGNAL_ARGS_BEGIN(StudioRenamed, "Studio name changed")
1282   SIGNAL_ARG_DESCRIBE("studio_name", "s", "New studio name")
1283 SIGNAL_ARGS_END
1284
1285 SIGNAL_ARGS_BEGIN(StudioStarted, "Studio started")
1286 SIGNAL_ARGS_END
1287
1288 SIGNAL_ARGS_BEGIN(StudioCrashed, "Studio crashed")
1289 SIGNAL_ARGS_END
1290
1291 SIGNAL_ARGS_BEGIN(StudioStopped, "Studio stopped")
1292 SIGNAL_ARGS_END
1293
1294 SIGNAL_ARGS_BEGIN(RoomAppeared, "Room D-Bus object appeared")
1295   SIGNAL_ARG_DESCRIBE("opath", "s", "room object path")
1296   SIGNAL_ARG_DESCRIBE("properties", "a{sv}", "room properties")
1297 SIGNAL_ARGS_END
1298
1299 SIGNAL_ARGS_BEGIN(RoomChanged, "Room D-Bus object changed")
1300   SIGNAL_ARG_DESCRIBE("opath", "s", "room object path")
1301   SIGNAL_ARG_DESCRIBE("properties", "a{sv}", "room properties")
1302 SIGNAL_ARGS_END
1303
1304 SIGNAL_ARGS_BEGIN(RoomDisappeared, "Room D-Bus object disappeared")
1305   SIGNAL_ARG_DESCRIBE("opath", "s", "room object path")
1306   SIGNAL_ARG_DESCRIBE("properties", "a{sv}", "room properties")
1307 SIGNAL_ARGS_END
1308
1309 SIGNALS_BEGIN
1310   SIGNAL_DESCRIBE(StudioRenamed)
1311   SIGNAL_DESCRIBE(StudioStarted)
1312   SIGNAL_DESCRIBE(StudioCrashed)
1313   SIGNAL_DESCRIBE(StudioStopped)
1314   SIGNAL_DESCRIBE(RoomAppeared)
1315   SIGNAL_DESCRIBE(RoomDisappeared)
1316   SIGNAL_DESCRIBE(RoomChanged)
1317 SIGNALS_END
1318
1319 INTERFACE_BEGIN(g_interface_studio, IFACE_STUDIO)
1320   INTERFACE_DEFAULT_HANDLER
1321   INTERFACE_EXPOSE_METHODS
1322   INTERFACE_EXPOSE_SIGNALS
1323 INTERFACE_END