daemon/studio.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the studio singleton object
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "common.h"
  28 #include "../jack_proxy.h"
  29 #include "patchbay.h"
  30 #include "../dbus_constants.h"
  31 #include "control.h"
  32
  33 extern const interface_t g_interface_studio;
  34
  35 struct studio
  36 {
  37   /* this must be first member of struct studio because object_path_new() assumes all interfaces have same context */
  38   struct patchbay_implementator patchbay_impl;
  39
  40   struct list_head all_connections;        /* All connections (studio guts and all rooms). Including superconnections. */
  41   struct list_head all_ports;              /* All ports (studio guts and all rooms) */
  42   struct list_head all_clients;            /* All clients (studio guts and all rooms) */
  43   struct list_head jack_connections;       /* JACK connections (studio guts and all rooms). Including superconnections, excluding virtual connections. */
  44   struct list_head jack_ports;             /* JACK ports (studio guts and all rooms). Excluding virtual ports. */
  45   struct list_head jack_clients;           /* JACK clients (studio guts and all rooms). Excluding virtual clients. */
  46   struct list_head rooms;                  /* Rooms connected to the studio */
  47   struct list_head clients;                /* studio clients (studio guts and room links) */
  48   struct list_head ports;                  /* studio ports (studio guts and room links) */
  49
  50   bool persisted:1;             /* Studio has on-disk representation, i.e. can be reloaded from disk */
  51   bool modified:1;              /* Studio needs saving */
  52   bool jack_conf_valid:1;       /* JACK server configuration obtained successfully */
  53
  54   struct list_head jack_conf;   /* root of the conf tree */
  55   struct list_head jack_params; /* list of conf tree leaves */
  56
  57   object_path_t * dbus_object;
  58
  59   struct list_head event_queue;
  60 } g_studio;
  61
  62 #define EVENT_JACK_START   0
  63 #define EVENT_JACK_STOP    1
  64
  65 struct event
  66 {
  67   struct list_head siblings;
  68   unsigned int type;
  69 };
  70
  71 #define JACK_CONF_MAX_ADDRESS_SIZE 1024
  72
  73 struct jack_conf_parameter
  74 {
  75   struct list_head siblings;    /* siblings in container children list */
  76   struct list_head leaves;      /* studio::jack_param siblings */
  77   char * name;
  78   struct jack_conf_container * parent_ptr;
  79   char address[JACK_CONF_MAX_ADDRESS_SIZE];
  80   struct jack_parameter_variant parameter;
  81 };
  82
  83 struct jack_conf_container
  84 {
  85   struct list_head siblings;
  86   char * name;
  87   struct jack_conf_container * parent_ptr;
  88   bool children_leafs;          /* if true, children are "jack_conf_parameter"s, if false, children are "jack_conf_container"s */
  89   struct list_head children;
  90 };
  91
  92 struct conf_callback_context
  93 {
  94   char address[JACK_CONF_MAX_ADDRESS_SIZE];
  95   struct list_head * container_ptr;
  96   struct jack_conf_container * parent_ptr;
  97 };
  98
  99 bool
 100 jack_conf_container_create(
 101   struct jack_conf_container ** container_ptr_ptr,
 102   const char * name)
 103 {
 104   struct jack_conf_container * container_ptr;
 105
 106   container_ptr = malloc(sizeof(struct jack_conf_container));
 107   if (container_ptr == NULL)
 108   {
 109     lash_error("malloc() failed to allocate struct jack_conf_container");
 110     goto fail;
 111   }
 112
 113   container_ptr->name = strdup(name);
 114   if (container_ptr->name == NULL)
 115   {
 116     lash_error("strdup() failed to duplicate \"%s\"", name);
 117     goto fail_free;
 118   }
 119
 120   INIT_LIST_HEAD(&container_ptr->children);
 121   container_ptr->children_leafs = false;
 122
 123   *container_ptr_ptr = container_ptr;
 124   return true;
 125
 126 fail_free:
 127   free(container_ptr);
 128
 129 fail:
 130   return false;
 131 }
 132
 133 bool
 134 jack_conf_parameter_create(
 135   struct jack_conf_parameter ** parameter_ptr_ptr,
 136   const char * name)
 137 {
 138   struct jack_conf_parameter * parameter_ptr;
 139
 140   parameter_ptr = malloc(sizeof(struct jack_conf_parameter));
 141   if (parameter_ptr == NULL)
 142   {
 143     lash_error("malloc() failed to allocate struct jack_conf_parameter");
 144     goto fail;
 145   }
 146
 147   parameter_ptr->name = strdup(name);
 148   if (parameter_ptr->name == NULL)
 149   {
 150     lash_error("strdup() failed to duplicate \"%s\"", name);
 151     goto fail_free;
 152   }
 153
 154   *parameter_ptr_ptr = parameter_ptr;
 155   return true;
 156
 157 fail_free:
 158   free(parameter_ptr);
 159
 160 fail:
 161   return false;
 162 }
 163
 164 void
 165 jack_conf_parameter_destroy(
 166   struct jack_conf_parameter * parameter_ptr)
 167 {
 168 #if 0
 169   lash_info("jack_conf_parameter destroy");
 170
 171   switch (parameter_ptr->parameter.type)
 172   {
 173   case jack_boolean:
 174     lash_info("%s value is %s (boolean)", parameter_ptr->name, parameter_ptr->parameter.value.boolean ? "true" : "false");
 175     break;
 176   case jack_string:
 177     lash_info("%s value is %s (string)", parameter_ptr->name, parameter_ptr->parameter.value.string);
 178     break;
 179   case jack_byte:
 180     lash_info("%s value is %u/%c (byte/char)", parameter_ptr->name, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 181     break;
 182   case jack_uint32:
 183     lash_info("%s value is %u (uint32)", parameter_ptr->name, (unsigned int)parameter_ptr->parameter.value.uint32);
 184     break;
 185   case jack_int32:
 186     lash_info("%s value is %u (int32)", parameter_ptr->name, (signed int)parameter_ptr->parameter.value.int32);
 187     break;
 188   default:
 189     lash_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, parameter_ptr->name);
 190     break;
 191   }
 192 #endif
 193
 194   if (parameter_ptr->parameter.type == jack_string)
 195   {
 196     free(parameter_ptr->parameter.value.string);
 197   }
 198
 199   free(parameter_ptr->name);
 200   free(parameter_ptr);
 201 }
 202
 203 void
 204 jack_conf_container_destroy(
 205   struct jack_conf_container * container_ptr)
 206 {
 207   struct list_head * node_ptr;
 208
 209   //lash_info("\"%s\" jack_conf_parameter destroy", container_ptr->name);
 210
 211   if (!container_ptr->children_leafs)
 212   {
 213     while (!list_empty(&container_ptr->children))
 214     {
 215       node_ptr = container_ptr->children.next;
 216       list_del(node_ptr);
 217       jack_conf_container_destroy(list_entry(node_ptr, struct jack_conf_container, siblings));
 218     }
 219   }
 220   else
 221   {
 222     while (!list_empty(&container_ptr->children))
 223     {
 224       node_ptr = container_ptr->children.next;
 225       list_del(node_ptr);
 226       jack_conf_parameter_destroy(list_entry(node_ptr, struct jack_conf_parameter, siblings));
 227     }
 228   }
 229
 230   free(container_ptr->name);
 231   free(container_ptr);
 232 }
 233
 234 #define context_ptr ((struct conf_callback_context *)context)
 235
 236 static
 237 bool
 238 conf_callback(
 239   void * context,
 240   bool leaf,
 241   const char * address,
 242   char * child)
 243 {
 244   char path[JACK_CONF_MAX_ADDRESS_SIZE];
 245   const char * component;
 246   char * dst;
 247   size_t len;
 248   bool is_set;
 249   struct jack_conf_container * parent_ptr;
 250   struct jack_conf_container * container_ptr;
 251   struct jack_conf_parameter * parameter_ptr;
 252
 253   parent_ptr = context_ptr->parent_ptr;
 254
 255   dst = path;
 256   component = address;
 257   while (*component != 0)
 258   {
 259     len = strlen(component);
 260     memcpy(dst, component, len);
 261     dst[len] = ':';
 262     component += len + 1;
 263     dst += len + 1;
 264   }
 265
 266   strcpy(dst, child);
 267
 268   /* address always is same buffer as the one supplied through context pointer */
 269   assert(context_ptr->address == address);
 270   dst = (char *)component;
 271
 272   len = strlen(child) + 1;
 273   memcpy(dst, child, len);
 274   dst[len] = 0;
 275
 276   if (leaf)
 277   {
 278     lash_debug("%s (leaf)", path);
 279
 280     if (parent_ptr == NULL)
 281     {
 282       lash_error("jack conf parameters can't appear in root container");
 283       return false;
 284     }
 285
 286     if (!parent_ptr->children_leafs)
 287     {
 288       if (!list_empty(&parent_ptr->children))
 289       {
 290         lash_error("jack conf parameters cant be mixed with containers at same hierarchy level");
 291         return false;
 292       }
 293
 294       parent_ptr->children_leafs = true;
 295     }
 296
 297     if (!jack_conf_parameter_create(&parameter_ptr, child))
 298     {
 299       lash_error("jack_conf_parameter_create() failed");
 300       return false;
 301     }
 302
 303     if (!jack_proxy_get_parameter_value(context_ptr->address, &is_set, &parameter_ptr->parameter))
 304     {
 305       lash_error("cannot get value of %s", path);
 306       return false;
 307     }
 308
 309     if (is_set)
 310     {
 311       switch (parameter_ptr->parameter.type)
 312       {
 313       case jack_boolean:
 314         lash_info("%s value is %s (boolean)", path, parameter_ptr->parameter.value.boolean ? "true" : "false");
 315         break;
 316       case jack_string:
 317         lash_info("%s value is %s (string)", path, parameter_ptr->parameter.value.string);
 318         break;
 319       case jack_byte:
 320         lash_info("%s value is %u/%c (byte/char)", path, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 321         break;
 322       case jack_uint32:
 323         lash_info("%s value is %u (uint32)", path, (unsigned int)parameter_ptr->parameter.value.uint32);
 324         break;
 325       case jack_int32:
 326         lash_info("%s value is %u (int32)", path, (signed int)parameter_ptr->parameter.value.int32);
 327         break;
 328       default:
 329         lash_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, path);
 330         jack_conf_parameter_destroy(parameter_ptr);
 331         return false;
 332       }
 333
 334       parameter_ptr->parent_ptr = parent_ptr;
 335       memcpy(parameter_ptr->address, context_ptr->address, JACK_CONF_MAX_ADDRESS_SIZE);
 336       list_add_tail(&parameter_ptr->siblings, &parent_ptr->children);
 337       list_add_tail(&parameter_ptr->leaves, &g_studio.jack_params);
 338     }
 339     else
 340     {
 341       jack_conf_parameter_destroy(parameter_ptr);
 342     }
 343   }
 344   else
 345   {
 346     lash_debug("%s (container)", path);
 347
 348     if (parent_ptr != NULL && parent_ptr->children_leafs)
 349     {
 350       lash_error("jack conf containers cant be mixed with parameters at same hierarchy level");
 351       return false;
 352     }
 353
 354     if (!jack_conf_container_create(&container_ptr, child))
 355     {
 356       lash_error("jack_conf_container_create() failed");
 357       return false;
 358     }
 359
 360     container_ptr->parent_ptr = parent_ptr;
 361
 362     if (parent_ptr == NULL)
 363     {
 364       list_add_tail(&container_ptr->siblings, &g_studio.jack_conf);
 365     }
 366     else
 367     {
 368       list_add_tail(&container_ptr->siblings, &parent_ptr->children);
 369     }
 370
 371     context_ptr->parent_ptr = container_ptr;
 372
 373     if (!jack_proxy_read_conf_container(context_ptr->address, context, conf_callback))
 374     {
 375       lash_error("cannot read container %s", path);
 376       return false;
 377     }
 378
 379     context_ptr->parent_ptr = parent_ptr;
 380   }
 381
 382   *dst = 0;
 383
 384   return true;
 385 }
 386
 387 #undef context_ptr
 388
 389 bool studio_fetch_jack_settings()
 390 {
 391   struct conf_callback_context context;
 392
 393   context.address[0] = 0;
 394   context.container_ptr = &g_studio.jack_conf;
 395   context.parent_ptr = NULL;
 396
 397   if (!jack_proxy_read_conf_container(context.address, &context, conf_callback))
 398   {
 399     lash_error("jack_proxy_read_conf_container() failed.");
 400     return false;
 401   }
 402
 403   return true;
 404 }
 405
 406 bool
 407 studio_activate(void)
 408 {
 409   object_path_t * object;
 410
 411   object = object_path_new(STUDIO_OBJECT_PATH, &g_studio, 2, &g_interface_studio, &g_interface_patchbay);
 412   if (object == NULL)
 413   {
 414     lash_error("object_path_new() failed");
 415     return false;
 416   }
 417
 418   if (!object_path_register(g_dbus_connection, object))
 419   {
 420     lash_error("object_path_register() failed");
 421     object_path_destroy(g_dbus_connection, object);
 422     return false;
 423   }
 424
 425   lash_info("Studio D-Bus object created.");
 426
 427   g_studio.dbus_object = object;
 428
 429   emit_studio_appeared();
 430
 431   return true;
 432 }
 433
 434 void
 435 studio_clear(void)
 436 {
 437   struct list_head * node_ptr;
 438
 439   g_studio.modified = false;
 440   g_studio.persisted = false;
 441
 442   while (!list_empty(&g_studio.jack_conf))
 443   {
 444     node_ptr = g_studio.jack_conf.next;
 445     list_del(node_ptr);
 446     jack_conf_container_destroy(list_entry(node_ptr, struct jack_conf_container, siblings));
 447   }
 448
 449   g_studio.jack_conf_valid = false;
 450
 451   if (g_studio.dbus_object != NULL)
 452   {
 453     object_path_destroy(g_dbus_connection, g_studio.dbus_object);
 454     g_studio.dbus_object = NULL;
 455     emit_studio_disappeared();
 456   }
 457 }
 458
 459 void
 460 studio_clear_if_not_persisted(void)
 461 {
 462   if (!g_studio.persisted)
 463   {
 464     studio_clear();
 465     return;
 466   }
 467 }
 468
 469 void on_event_jack_started(void)
 470 {
 471   if (g_studio.dbus_object == NULL)
 472   {
 473     studio_activate();
 474   }
 475
 476   if (!studio_fetch_jack_settings(g_studio))
 477   {
 478     lash_error("studio_fetch_jack_settings() failed.");
 479
 480     studio_clear_if_not_persisted();
 481     return;
 482   }
 483
 484   lash_info("jack conf successfully retrieved");
 485   g_studio.jack_conf_valid = true;
 486 }
 487
 488 void on_event_jack_stopped(void)
 489 {
 490   studio_clear_if_not_persisted();
 491
 492   /* TODO: if user wants, restart jack server and reconnect all jack apps to it */
 493 }
 494
 495 void studio_run(void)
 496 {
 497   struct event * event_ptr;
 498
 499   while (!list_empty(&g_studio.event_queue))
 500   {
 501     event_ptr = list_entry(g_studio.event_queue.next, struct event, siblings);
 502     list_del(g_studio.event_queue.next);
 503
 504     switch (event_ptr->type)
 505     {
 506     case EVENT_JACK_START:
 507       on_event_jack_started();
 508       break;
 509     case EVENT_JACK_STOP:
 510       on_event_jack_stopped();
 511       break;
 512     }
 513
 514     free(event_ptr);
 515   }
 516 }
 517
 518 static void on_jack_server_started(void)
 519 {
 520   struct event * event_ptr;
 521
 522   lash_info("JACK server start detected.");
 523
 524   event_ptr = malloc(sizeof(struct event));
 525   if (event_ptr == NULL)
 526   {
 527     lash_error("malloc() failed to allocate struct event. Ignoring JACK start.");
 528     return;
 529   }
 530
 531   event_ptr->type = EVENT_JACK_START;
 532   list_add_tail(&event_ptr->siblings, &g_studio.event_queue);
 533 }
 534
 535 static void on_jack_server_stopped(void)
 536 {
 537   struct event * event_ptr;
 538
 539   lash_info("JACK server stop detected.");
 540
 541   event_ptr = malloc(sizeof(struct event));
 542   if (event_ptr == NULL)
 543   {
 544     lash_error("malloc() failed to allocate struct event. Ignoring JACK stop.");
 545     return;
 546   }
 547
 548   event_ptr->type = EVENT_JACK_STOP;
 549   list_add_tail(&event_ptr->siblings, &g_studio.event_queue);
 550 }
 551
 552 static void on_jack_server_appeared(void)
 553 {
 554   lash_info("JACK controller appeared.");
 555 }
 556
 557 static void on_jack_server_disappeared(void)
 558 {
 559   lash_info("JACK controller disappeared.");
 560 }
 561
 562 #define studio_ptr ((struct studio *)this)
 563
 564 uint64_t
 565 studio_get_graph_version(
 566   void * this)
 567 {
 568   //lash_info("studio_get_graph_version() called");
 569   return 1;
 570 }
 571
 572 #undef studio_ptr
 573
 574 bool studio_init(void)
 575 {
 576   lash_info("studio object construct");
 577
 578   g_studio.patchbay_impl.this = &g_studio;
 579   g_studio.patchbay_impl.get_graph_version = studio_get_graph_version;
 580
 581   INIT_LIST_HEAD(&g_studio.all_connections);
 582   INIT_LIST_HEAD(&g_studio.all_ports);
 583   INIT_LIST_HEAD(&g_studio.all_clients);
 584   INIT_LIST_HEAD(&g_studio.jack_connections);
 585   INIT_LIST_HEAD(&g_studio.jack_ports);
 586   INIT_LIST_HEAD(&g_studio.jack_clients);
 587   INIT_LIST_HEAD(&g_studio.rooms);
 588   INIT_LIST_HEAD(&g_studio.clients);
 589   INIT_LIST_HEAD(&g_studio.ports);
 590
 591   INIT_LIST_HEAD(&g_studio.jack_conf);
 592   INIT_LIST_HEAD(&g_studio.jack_params);
 593
 594   INIT_LIST_HEAD(&g_studio.event_queue);
 595
 596   g_studio.dbus_object = NULL;
 597   studio_clear();
 598
 599   if (!jack_proxy_init(
 600         on_jack_server_started,
 601         on_jack_server_stopped,
 602         on_jack_server_appeared,
 603         on_jack_server_disappeared))
 604   {
 605     return false;
 606   }
 607
 608   return true;
 609 }
 610
 611 void studio_uninit(void)
 612 {
 613   jack_proxy_uninit();
 614
 615   studio_clear();
 616
 617   lash_info("studio object destroy");
 618 }
 619
 620 bool studio_is_loaded(void)
 621 {
 622   return g_studio.dbus_object != NULL;
 623 }
 624
 625 bool studio_save(const char * file_path)
 626 {
 627   struct list_head * node_ptr;
 628   struct jack_conf_parameter * parameter_ptr;
 629   char path[JACK_CONF_MAX_ADDRESS_SIZE * 3]; /* encode each char in three bytes (percent encoding) */
 630   const char * src;
 631   char * dst;
 632   static char hex_digits[] = "0123456789ABCDEF";
 633
 634   lash_info("saving studio...");
 635
 636   list_for_each(node_ptr, &g_studio.jack_params)
 637   {
 638     parameter_ptr = list_entry(node_ptr, struct jack_conf_parameter, leaves);
 639
 640     /* compose the parameter path, percent-encode "bad" chars */
 641     src = parameter_ptr->address;
 642     dst = path;
 643     do
 644     {
 645       *dst++ = '/';
 646       while (*src != 0)
 647       {
 648         switch (*src)
 649         {
 650         case '/':               /* used as separator for address components */
 651         case '<':               /* invalid attribute value char (XML spec) */
 652         case '&':               /* invalid attribute value char (XML spec) */
 653         case '"':               /* we store attribute values in double quotes - invalid attribute value char (XML spec) */
 654         case '%':
 655           dst[0] = '%';
 656           dst[1] = hex_digits[*src >> 4];
 657           dst[2] = hex_digits[*src & 0x0F];
 658           dst += 3;
 659           src++;
 660           break;
 661         default:
 662           *dst++ = *src++;
 663         }
 664       }
 665       src++;
 666     }
 667     while (*src != 0);
 668     *dst = 0;
 669
 670     switch (parameter_ptr->parameter.type)
 671     {
 672     case jack_boolean:
 673       lash_info("%s value is %s (boolean)", path, parameter_ptr->parameter.value.boolean ? "true" : "false");
 674       break;
 675     case jack_string:
 676       lash_info("%s value is %s (string)", path, parameter_ptr->parameter.value.string);
 677       break;
 678     case jack_byte:
 679       lash_info("%s value is %u/%c (byte/char)", path, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 680       break;
 681     case jack_uint32:
 682       lash_info("%s value is %u (uint32)", path, (unsigned int)parameter_ptr->parameter.value.uint32);
 683       break;
 684     case jack_int32:
 685       lash_info("%s value is %u (int32)", path, (signed int)parameter_ptr->parameter.value.int32);
 686       break;
 687     default:
 688       lash_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, path);
 689       return false;
 690     }
 691   }
 692
 693   return false;                 /* not implemented yet */
 694 }
 695
 696 bool studio_load(const char * file_path)
 697 {
 698   return false;                 /* not implemented yet */
 699 }
 700
 701 static void ladish_save_studio(method_call_t * call_ptr)
 702 {
 703   //studio_save(g_studio, NULL)
 704 }
 705
 706 METHOD_ARGS_BEGIN(Save, "Save studio")
 707 METHOD_ARGS_END
 708
 709 METHODS_BEGIN
 710   METHOD_DESCRIBE(Save, ladish_save_studio)
 711 METHODS_END
 712
 713 SIGNAL_ARGS_BEGIN(RoomAppeared, "Room D-Bus object appeared")
 714   SIGNAL_ARG_DESCRIBE("room_path", "s", "room object path")
 715 SIGNAL_ARGS_END
 716
 717 SIGNAL_ARGS_BEGIN(RoomDisappeared, "Room D-Bus object disappeared")
 718   SIGNAL_ARG_DESCRIBE("room_path", "s", "room object path")
 719 SIGNAL_ARGS_END
 720
 721 SIGNALS_BEGIN
 722   SIGNAL_DESCRIBE(RoomAppeared)
 723   SIGNAL_DESCRIBE(RoomDisappeared)
 724 SIGNALS_END
 725
 726 INTERFACE_BEGIN(g_interface_studio, IFACE_STUDIO)
 727   INTERFACE_DEFAULT_HANDLER
 728   INTERFACE_EXPOSE_METHODS
 729   INTERFACE_EXPOSE_SIGNALS
 730 INTERFACE_END