daemon/cmd_load_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 implementation of the "load studio" command
   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
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33
  34 #include "escape.h"
  35 #include "cmd.h"
  36 #include "studio_internal.h"
  37 #include "../proxies/notify_proxy.h"
  38 #include "load.h"
  39
  40 #define context_ptr ((struct ladish_parse_context *)data)
  41
  42 static void callback_chrdata(void * data, const XML_Char * s, int len)
  43 {
  44   if (context_ptr->error)
  45   {
  46     return;
  47   }
  48
  49   if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_PARAMETER ||
  50       context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_KEY ||
  51       context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_APPLICATION)
  52   {
  53     if (context_ptr->data_used + len >= sizeof(context_ptr->data))
  54     {
  55       log_error("xml parse max char data length reached");
  56       context_ptr->error = XML_TRUE;
  57       return;
  58     }
  59
  60     memcpy(context_ptr->data + context_ptr->data_used, s, len);
  61     context_ptr->data_used += len;
  62   }
  63 }
  64
  65 static void callback_elstart(void * data, const char * el, const char ** attr)
  66 {
  67   const char * name;
  68   const char * path;
  69   const char * uuid_str;
  70   uuid_t uuid;
  71   const char * uuid2_str;
  72   uuid_t uuid2;
  73   ladish_port_handle port1;
  74   ladish_port_handle port2;
  75   uint32_t port_type;
  76   uint32_t port_flags;
  77
  78   if (context_ptr->error)
  79   {
  80     return;
  81   }
  82
  83   if (context_ptr->depth + 1 >= MAX_STACK_DEPTH)
  84   {
  85     log_error("xml parse max stack depth reached");
  86     context_ptr->error = XML_TRUE;
  87     return;
  88   }
  89
  90   if (strcmp(el, "studio") == 0)
  91   {
  92     //log_info("<studio>");
  93     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_STUDIO;
  94     return;
  95   }
  96
  97   if (strcmp(el, "jack") == 0)
  98   {
  99     //log_info("<jack>");
 100     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_JACK;
 101     return;
 102   }
 103
 104   if (strcmp(el, "conf") == 0)
 105   {
 106     //log_info("<conf>");
 107     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_CONF;
 108     return;
 109   }
 110
 111   if (strcmp(el, "parameter") == 0)
 112   {
 113     //log_info("<parameter>");
 114     path = ladish_get_string_attribute(attr, "path");
 115     if (path == NULL)
 116     {
 117       log_error("<parameter> XML element without \"path\" attribute");
 118       context_ptr->error = XML_TRUE;
 119       return;
 120     }
 121
 122     context_ptr->str = strdup(path);
 123     if (context_ptr->str == NULL)
 124     {
 125       log_error("strdup() failed");
 126       context_ptr->error = XML_TRUE;
 127       return;
 128     }
 129
 130     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_PARAMETER;
 131     context_ptr->data_used = 0;
 132     return;
 133   }
 134
 135   if (strcmp(el, "clients") == 0)
 136   {
 137     //log_info("<clients>");
 138     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_CLIENTS;
 139     return;
 140   }
 141
 142   if (strcmp(el, "rooms") == 0)
 143   {
 144     //log_info("<rooms>");
 145     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_ROOMS;
 146     return;
 147   }
 148
 149   if (strcmp(el, "room") == 0)
 150   {
 151     //log_info("<room>");
 152     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_ROOM;
 153
 154     if (context_ptr->room != NULL)
 155     {
 156         log_error("nested rooms");
 157         context_ptr->error = XML_TRUE;
 158         return;
 159     }
 160
 161     if (context_ptr->depth == 2 &&
 162         context_ptr->element[0] == PARSE_CONTEXT_STUDIO &&
 163         context_ptr->element[1] == PARSE_CONTEXT_ROOMS)
 164     {
 165       if (!ladish_get_name_and_uuid_attributes("/studio/rooms/room", attr, &name, &uuid_str, uuid))
 166       {
 167         context_ptr->error = XML_TRUE;
 168         return;
 169       }
 170
 171       if (!ladish_room_create(uuid, name, NULL, g_studio.studio_graph, &context_ptr->room))
 172       {
 173         log_error("ladish_room_create() failed.");
 174         context_ptr->error = XML_TRUE;
 175         ASSERT(context_ptr->room == NULL);
 176         return;
 177       }
 178
 179       return;
 180     }
 181
 182     log_error("ignoring <room> element in wrong context");
 183     return;
 184   }
 185
 186   if (strcmp(el, "client") == 0)
 187   {
 188     //log_info("<client>");
 189     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_CLIENT;
 190
 191     if (context_ptr->client != NULL)
 192     {
 193         log_error("nested clients");
 194         context_ptr->error = XML_TRUE;
 195         return;
 196     }
 197
 198     if (context_ptr->depth == 3 &&
 199         context_ptr->element[0] == PARSE_CONTEXT_STUDIO &&
 200         context_ptr->element[1] == PARSE_CONTEXT_JACK &&
 201         context_ptr->element[2] == PARSE_CONTEXT_CLIENTS)
 202     {
 203       if (!ladish_get_name_and_uuid_attributes("/studio/jack/clients/client", attr, &name, &uuid_str, uuid))
 204       {
 205         context_ptr->error = XML_TRUE;
 206         return;
 207       }
 208
 209       log_info("jack client \"%s\" with uuid %s", name, uuid_str);
 210
 211       if (!ladish_client_create(uuid, &context_ptr->client))
 212       {
 213         log_error("ladish_client_create() failed.");
 214         context_ptr->error = XML_TRUE;
 215         ASSERT(context_ptr->client == NULL);
 216         return;
 217       }
 218
 219       if (!ladish_graph_add_client(g_studio.jack_graph, context_ptr->client, name, true))
 220       {
 221         log_error("ladish_graph_add_client() failed to add client '%s' to JACK graph", name);
 222         context_ptr->error = XML_TRUE;
 223         ladish_client_destroy(context_ptr->client);
 224         context_ptr->client = NULL;
 225         return;
 226       }
 227     }
 228     else if (context_ptr->depth == 2 &&
 229              context_ptr->element[0] == PARSE_CONTEXT_STUDIO &&
 230              context_ptr->element[1] == PARSE_CONTEXT_CLIENTS)
 231     {
 232       if (!ladish_get_name_and_uuid_attributes("/studio/clients/client", attr, &name, &uuid_str, uuid))
 233       {
 234         context_ptr->error = XML_TRUE;
 235         return;
 236       }
 237
 238       log_info("studio client \"%s\" with uuid %s", name, uuid_str);
 239
 240       context_ptr->client = ladish_graph_find_client_by_uuid(g_studio.studio_graph, uuid);
 241       if (context_ptr->client != NULL)
 242       {
 243         log_info("Found existing client");
 244         return;
 245       }
 246
 247       if (!ladish_client_create(uuid, &context_ptr->client))
 248       {
 249         log_error("ladish_client_create() failed.");
 250         context_ptr->error = XML_TRUE;
 251         ASSERT(context_ptr->client == NULL);
 252         return;
 253       }
 254
 255       if (!ladish_graph_add_client(g_studio.studio_graph, context_ptr->client, name, true))
 256       {
 257         log_error("ladish_graph_add_client() failed to add client '%s' to studio graph", name);
 258         context_ptr->error = XML_TRUE;
 259         ladish_client_destroy(context_ptr->client);
 260         context_ptr->client = NULL;
 261         return;
 262       }
 263     }
 264
 265     return;
 266   }
 267
 268   if (strcmp(el, "ports") == 0)
 269   {
 270     //log_info("<ports>");
 271     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_PORTS;
 272     return;
 273   }
 274
 275   if (strcmp(el, "port") == 0)
 276   {
 277     //log_info("<port>");
 278     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_PORT;
 279
 280     if (context_ptr->port != NULL)
 281     {
 282         log_error("nested ports");
 283         context_ptr->error = XML_TRUE;
 284         return;
 285     }
 286
 287     if (context_ptr->depth >= 3 &&
 288         context_ptr->element[context_ptr->depth - 3] == PARSE_CONTEXT_CLIENTS &&
 289         context_ptr->element[context_ptr->depth - 2] == PARSE_CONTEXT_CLIENT &&
 290         context_ptr->element[context_ptr->depth - 1] == PARSE_CONTEXT_PORTS)
 291     {
 292       //log_info("client port");
 293       if (context_ptr->client == NULL)
 294       {
 295         log_error("client-less port");
 296         context_ptr->error = XML_TRUE;
 297         return;
 298       }
 299
 300       if (context_ptr->depth == 5 && context_ptr->element[0] == PARSE_CONTEXT_STUDIO && context_ptr->element[1] == PARSE_CONTEXT_JACK)
 301       {
 302         if (!ladish_get_name_and_uuid_attributes("/studio/jack/clients/client/ports/port", attr, &name, &uuid_str, uuid))
 303         {
 304           context_ptr->error = XML_TRUE;
 305           return;
 306         }
 307
 308         log_info("jack port \"%s\" with uuid %s", name, uuid_str);
 309
 310         if (!ladish_port_create(uuid, false, &context_ptr->port))
 311         {
 312           log_error("ladish_port_create() failed.");
 313           return;
 314         }
 315
 316         if (!ladish_graph_add_port(g_studio.jack_graph, context_ptr->client, context_ptr->port, name, 0, 0, true))
 317         {
 318           log_error("ladish_graph_add_port() failed.");
 319           ladish_port_destroy(context_ptr->port);
 320           context_ptr->port = NULL;
 321         }
 322
 323         return;
 324       }
 325       else if (context_ptr->depth == 4 && context_ptr->element[0] == PARSE_CONTEXT_STUDIO)
 326       {
 327         if (!ladish_get_name_and_uuid_attributes("/studio/clients/client/ports/port", attr, &name, &uuid_str, uuid))
 328         {
 329           context_ptr->error = XML_TRUE;
 330           return;
 331         }
 332
 333         uuid2_str = ladish_get_uuid_attribute(attr, "link_uuid", uuid2, true);
 334
 335         log_info("studio port \"%s\" with uuid %s (%s)", name, uuid_str, uuid2_str == NULL ? "normal" : "room link");
 336
 337         if (uuid2_str == NULL)
 338         { /* normal studio port */
 339           context_ptr->port = ladish_graph_find_port_by_uuid(g_studio.jack_graph, uuid, false);
 340           if (context_ptr->port == NULL)
 341           {
 342             log_error("studio client with non-jack port %s", uuid_str);
 343             context_ptr->error = XML_TRUE;
 344             return;
 345           }
 346
 347           if (!ladish_graph_add_port(g_studio.studio_graph, context_ptr->client, context_ptr->port, name, 0, 0, true))
 348           {
 349             log_error("ladish_graph_add_port() failed.");
 350             ladish_port_destroy(context_ptr->port);
 351             context_ptr->port = NULL;
 352             return;
 353           }
 354
 355           return;
 356         }
 357
 358         /* room link port */
 359         context_ptr->port = ladish_graph_find_client_port_by_uuid(g_studio.studio_graph, context_ptr->client, uuid2, false);
 360         if (context_ptr->port == NULL)
 361         {
 362           log_error("room link port not found");
 363           context_ptr->error = XML_TRUE;
 364           return;
 365         }
 366
 367         ladish_graph_set_link_port_override_uuid(g_studio.studio_graph, context_ptr->port, uuid);
 368         return;
 369       }
 370     }
 371     else if (context_ptr->depth == 3 &&
 372              context_ptr->element[0] == PARSE_CONTEXT_STUDIO &&
 373              context_ptr->element[1] == PARSE_CONTEXT_ROOMS &&
 374              context_ptr->element[2] == PARSE_CONTEXT_ROOM)
 375     {
 376       ASSERT(context_ptr->room != NULL);
 377       //log_info("room port");
 378
 379       if (!ladish_get_name_and_uuid_attributes("/studio/rooms/room/port", attr, &name, &uuid_str, uuid))
 380       {
 381         context_ptr->error = XML_TRUE;
 382         return;
 383       }
 384
 385       log_info("room port \"%s\" with uuid %s", name, uuid_str);
 386
 387       if (!ladish_parse_port_type_and_direction_attributes("/studio/rooms/room/port", attr, &port_type, &port_flags))
 388       {
 389         context_ptr->error = XML_TRUE;
 390         return;
 391       }
 392
 393       context_ptr->port = ladish_room_add_port(context_ptr->room, uuid, name, port_type, port_flags);
 394       if (context_ptr->port == NULL)
 395       {
 396         log_error("ladish_room_add_port() failed.");
 397         context_ptr->port = NULL;
 398       }
 399
 400       return;
 401     }
 402
 403     log_error("port element in wrong place");
 404     ladish_dump_element_stack(context_ptr);
 405     context_ptr->error = XML_TRUE;
 406     return;
 407   }
 408
 409   if (strcmp(el, "connections") == 0)
 410   {
 411     //log_info("<connections>");
 412     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_CONNECTIONS;
 413     return;
 414   }
 415
 416   if (strcmp(el, "connection") == 0)
 417   {
 418     //log_info("<connection>");
 419     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_CONNECTION;
 420
 421     uuid_str = ladish_get_uuid_attribute(attr, "port1", uuid, false);
 422     if (uuid_str == NULL)
 423     {
 424       log_error("/studio/connections/connection \"port1\" attribute is not available.");
 425       context_ptr->error = XML_TRUE;
 426       return;
 427     }
 428
 429     uuid2_str = ladish_get_uuid_attribute(attr, "port2", uuid2, false);
 430     if (uuid2_str == NULL)
 431     {
 432       log_error("/studio/connections/connection \"port2\" attribute is not available.");
 433       context_ptr->error = XML_TRUE;
 434       return;
 435     }
 436
 437     log_info("studio connection between port %s and port %s", uuid_str, uuid2_str);
 438
 439     port1 = ladish_graph_find_port_by_uuid(g_studio.studio_graph, uuid, true);
 440     if (port1 == NULL)
 441     {
 442       log_error("studio client with unknown port %s", uuid_str);
 443       context_ptr->error = XML_TRUE;
 444       return;
 445     }
 446
 447     port2 = ladish_graph_find_port_by_uuid(g_studio.studio_graph, uuid2, true);
 448     if (port2 == NULL)
 449     {
 450       log_error("studio client with unknown port %s", uuid2_str);
 451       context_ptr->error = XML_TRUE;
 452       return;
 453     }
 454
 455     context_ptr->connection_id = ladish_graph_add_connection(g_studio.studio_graph, port1, port2, true);
 456     if (context_ptr->connection_id == 0)
 457     {
 458       log_error("ladish_graph_add_connection() failed.");
 459       return;
 460     }
 461
 462     return;
 463   }
 464
 465   if (strcmp(el, "applications") == 0)
 466   {
 467     //log_info("<applications>");
 468     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_APPLICATIONS;
 469     return;
 470   }
 471
 472   if (strcmp(el, "application") == 0)
 473   {
 474     //log_info("<application>");
 475     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_APPLICATION;
 476
 477     name = ladish_get_string_attribute(attr, "name");
 478     if (name == NULL)
 479     {
 480       log_error("application \"name\" attribute is not available.");
 481       context_ptr->error = XML_TRUE;
 482       return;
 483     }
 484
 485     if (ladish_get_bool_attribute(attr, "terminal", &context_ptr->terminal) == NULL)
 486     {
 487       log_error("application \"terminal\" attribute is not available. name=\"%s\"", name);
 488       context_ptr->error = XML_TRUE;
 489       return;
 490     }
 491
 492     if (ladish_get_bool_attribute(attr, "autorun", &context_ptr->autorun) == NULL)
 493     {
 494       log_error("application \"autorun\" attribute is not available. name=\"%s\"", name);
 495       context_ptr->error = XML_TRUE;
 496       return;
 497     }
 498
 499     if (ladish_get_byte_attribute(attr, "level", &context_ptr->level) == NULL)
 500     {
 501       log_error("application \"level\" attribute is not available. name=\"%s\"", name);
 502       context_ptr->error = XML_TRUE;
 503       return;
 504     }
 505
 506     context_ptr->str = strdup(name);
 507     if (context_ptr->str == NULL)
 508     {
 509       log_error("strdup() failed");
 510       context_ptr->error = XML_TRUE;
 511       return;
 512     }
 513
 514     context_ptr->data_used = 0;
 515     return;
 516   }
 517
 518   if (strcmp(el, "dict") == 0)
 519   {
 520     //log_info("<dict>");
 521     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_DICT;
 522
 523     if (context_ptr->dict != NULL)
 524     {
 525         log_error("nested dicts");
 526         context_ptr->error = XML_TRUE;
 527         return;
 528     }
 529
 530     if (context_ptr->depth == 1 &&
 531         context_ptr->element[0] == PARSE_CONTEXT_STUDIO)
 532     {
 533       context_ptr->dict = ladish_graph_get_dict(g_studio.studio_graph);
 534       ASSERT(context_ptr->dict != NULL);
 535     }
 536     else if (context_ptr->depth > 0 &&
 537              context_ptr->element[context_ptr->depth - 1] == PARSE_CONTEXT_CLIENT)
 538     {
 539       ASSERT(context_ptr->client != NULL);
 540       context_ptr->dict = ladish_client_get_dict(context_ptr->client);
 541       ASSERT(context_ptr->dict != NULL);
 542     }
 543     else if (context_ptr->depth > 0 &&
 544              context_ptr->element[context_ptr->depth - 1] == PARSE_CONTEXT_PORT)
 545     {
 546       ASSERT(context_ptr->port != NULL);
 547       context_ptr->dict = ladish_port_get_dict(context_ptr->port);
 548       ASSERT(context_ptr->dict != NULL);
 549     }
 550     else if (context_ptr->depth > 0 &&
 551              context_ptr->element[context_ptr->depth - 1] == PARSE_CONTEXT_CONNECTION)
 552     {
 553       ASSERT(context_ptr->port != NULL);
 554       context_ptr->dict = ladish_graph_get_connection_dict(g_studio.studio_graph, context_ptr->connection_id);
 555       ASSERT(context_ptr->dict != NULL);
 556     }
 557     else
 558     {
 559       log_error("unexpected dict XML element");
 560       context_ptr->error = XML_TRUE;
 561       return;
 562     }
 563
 564     return;
 565   }
 566
 567   if (strcmp(el, "key") == 0)
 568   {
 569     //log_info("<key>");
 570     context_ptr->element[++context_ptr->depth] = PARSE_CONTEXT_KEY;
 571
 572     if (context_ptr->dict == NULL)
 573     {
 574         log_error("dict-less key");
 575         context_ptr->error = XML_TRUE;
 576         return;
 577     }
 578
 579     name = ladish_get_string_attribute(attr, "name");
 580     if (name == NULL)
 581     {
 582       log_error("dict/key \"name\" attribute is not available.");
 583       context_ptr->error = XML_TRUE;
 584       return;
 585     }
 586
 587     context_ptr->str = strdup(name);
 588     if (context_ptr->str == NULL)
 589     {
 590       log_error("strdup() failed");
 591       context_ptr->error = XML_TRUE;
 592       return;
 593     }
 594
 595     context_ptr->data_used = 0;
 596
 597     return;
 598   }
 599
 600   log_error("unknown element \"%s\"", el);
 601   context_ptr->error = XML_TRUE;
 602 }
 603
 604 static void callback_elend(void * data, const char * el)
 605 {
 606   char * src;
 607   char * dst;
 608   char * sep;
 609   size_t src_len;
 610   size_t dst_len;
 611   char * address;
 612   struct jack_parameter_variant parameter;
 613   bool is_set;
 614
 615   if (context_ptr->error)
 616   {
 617     return;
 618   }
 619
 620   //log_info("element end (depth = %d, element = %u)", context_ptr->depth, context_ptr->element[context_ptr->depth]);
 621
 622   if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_PARAMETER &&
 623       context_ptr->depth == 3 &&
 624       context_ptr->element[0] == PARSE_CONTEXT_STUDIO &&
 625       context_ptr->element[1] == PARSE_CONTEXT_JACK &&
 626       context_ptr->element[2] == PARSE_CONTEXT_CONF)
 627   {
 628     context_ptr->data[context_ptr->data_used] = 0;
 629
 630     //log_info("'%s' with value '%s'", context_ptr->str, context_ptr->data);
 631
 632     dst = address = strdup(context_ptr->str);
 633     src = context_ptr->str + 1;
 634     while (*src != 0)
 635     {
 636       sep = strchr(src, '/');
 637       if (sep == NULL)
 638       {
 639         src_len = strlen(src);
 640       }
 641       else
 642       {
 643         src_len = sep - src;
 644       }
 645
 646       dst_len = unescape(src, src_len, dst);
 647       dst[dst_len] = 0;
 648       dst += dst_len + 1;
 649
 650       src += src_len;
 651       ASSERT(*src == '/' || *src == 0);
 652       if (sep != NULL)
 653       {
 654         ASSERT(*src == '/');
 655         src++;                  /* skip separator */
 656       }
 657       else
 658       {
 659         ASSERT(*src == 0);
 660       }
 661     }
 662     *dst = 0;                   /* ASCIZZ */
 663
 664     if (!jack_proxy_get_parameter_value(address, &is_set, &parameter))
 665     {
 666       log_error("jack_proxy_get_parameter_value() failed");
 667       goto fail_free_address;
 668     }
 669
 670     if (parameter.type == jack_string)
 671     {
 672       free(parameter.value.string);
 673     }
 674
 675     switch (parameter.type)
 676     {
 677     case jack_boolean:
 678       log_info("%s value is %s (boolean)", context_ptr->str, context_ptr->data);
 679       if (strcmp(context_ptr->data, "true") == 0)
 680       {
 681         parameter.value.boolean = true;
 682       }
 683       else if (strcmp(context_ptr->data, "false") == 0)
 684       {
 685         parameter.value.boolean = false;
 686       }
 687       else
 688       {
 689         log_error("bad value for a bool jack param");
 690         goto fail_free_address;
 691       }
 692       break;
 693     case jack_string:
 694       log_info("%s value is %s (string)", context_ptr->str, context_ptr->data);
 695       parameter.value.string = context_ptr->data;
 696       break;
 697     case jack_byte:
 698       log_debug("%s value is %u/%c (byte/char)", context_ptr->str, *context_ptr->data, *context_ptr->data);
 699       if (context_ptr->data[0] == 0 ||
 700           context_ptr->data[1] != 0)
 701       {
 702         log_error("bad value for a char jack param");
 703         goto fail_free_address;
 704       }
 705       parameter.value.byte = context_ptr->data[0];
 706       break;
 707     case jack_uint32:
 708       log_info("%s value is %s (uint32)", context_ptr->str, context_ptr->data);
 709       if (sscanf(context_ptr->data, "%" PRIu32, &parameter.value.uint32) != 1)
 710       {
 711         log_error("bad value for an uint32 jack param");
 712         goto fail_free_address;
 713       }
 714       break;
 715     case jack_int32:
 716       log_info("%s value is %s (int32)", context_ptr->str, context_ptr->data);
 717       if (sscanf(context_ptr->data, "%" PRIi32, &parameter.value.int32) != 1)
 718       {
 719         log_error("bad value for an int32 jack param");
 720         goto fail_free_address;
 721       }
 722       break;
 723     default:
 724       log_error("unknown jack parameter type %d of %s", (int)parameter.type, context_ptr->str);
 725       goto fail_free_address;
 726     }
 727
 728     if (!jack_proxy_set_parameter_value(address, &parameter))
 729     {
 730       log_error("jack_proxy_set_parameter_value() failed");
 731       goto fail_free_address;
 732     }
 733
 734     free(address);
 735   }
 736   else if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_KEY &&
 737            context_ptr->depth > 0 &&
 738            context_ptr->element[context_ptr->depth - 1] == PARSE_CONTEXT_DICT)
 739   {
 740     ASSERT(context_ptr->dict != NULL);
 741     context_ptr->data[context_ptr->data_used] = 0;
 742     log_info("dict key '%s' with value '%s'", context_ptr->str, context_ptr->data);
 743     if (!ladish_dict_set(context_ptr->dict, context_ptr->str, context_ptr->data))
 744     {
 745       log_error("ladish_dict_set() failed");
 746       context_ptr->error = XML_TRUE;
 747       return;
 748     }
 749   }
 750   else if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_ROOM)
 751   {
 752     //log_info("</room>");
 753     ASSERT(context_ptr->room != NULL);
 754     context_ptr->room = NULL;
 755   }
 756   else if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_DICT)
 757   {
 758     //log_info("</dict>");
 759     ASSERT(context_ptr->dict != NULL);
 760     context_ptr->dict = NULL;
 761   }
 762   else if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_CLIENT)
 763   {
 764     //log_info("</client>");
 765     ASSERT(context_ptr->client != NULL);
 766     context_ptr->client = NULL;
 767   }
 768   else if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_PORT)
 769   {
 770     //log_info("</port>");
 771     ASSERT(context_ptr->port != NULL);
 772     context_ptr->port = NULL;
 773   }
 774   else if (context_ptr->element[context_ptr->depth] == PARSE_CONTEXT_APPLICATION)
 775   {
 776     context_ptr->data[unescape(context_ptr->data, context_ptr->data_used, context_ptr->data)] = 0;
 777     unescape(context_ptr->str, strlen(context_ptr->str) + 1, context_ptr->str);
 778
 779     log_info("application '%s' (%s, %s, level %u) with commandline '%s'", context_ptr->str, context_ptr->terminal ? "terminal" : "shell", context_ptr->autorun ? "autorun" : "stopped", (unsigned int)context_ptr->level, context_ptr->data);
 780
 781     if (ladish_app_supervisor_add(g_studio.app_supervisor, context_ptr->str, context_ptr->autorun, context_ptr->data, context_ptr->terminal, context_ptr->level) == NULL)
 782     {
 783       log_error("ladish_app_supervisor_add() failed.");
 784       context_ptr->error = XML_TRUE;
 785     }
 786   }
 787
 788   context_ptr->depth--;
 789
 790   if (context_ptr->str != NULL)
 791   {
 792     free(context_ptr->str);
 793     context_ptr->str = NULL;
 794   }
 795
 796   return;
 797
 798 fail_free_address:
 799   free(address);
 800   context_ptr->error = XML_TRUE;
 801   return;
 802 }
 803
 804 #undef context_ptr
 805
 806 struct ladish_command_load_studio
 807 {
 808   struct ladish_command command;
 809   char * studio_name;
 810 };
 811
 812 #define cmd_ptr ((struct ladish_command_load_studio *)command_context)
 813
 814 static bool run(void * command_context)
 815 {
 816   char * path;
 817   struct stat st;
 818   XML_Parser parser;
 819   int bytes_read;
 820   void * buffer;
 821   int fd;
 822   enum XML_Status xmls;
 823   struct ladish_parse_context parse_context;
 824
 825   ASSERT(cmd_ptr->command.state == LADISH_COMMAND_STATE_PENDING);
 826
 827   if (!ladish_studio_compose_filename(cmd_ptr->studio_name, &path, NULL))
 828   {
 829     log_error("failed to compose path of studio \%s\" file", cmd_ptr->studio_name);
 830     return false;
 831   }
 832
 833   log_info("Loading studio... ('%s')", path);
 834
 835   if (stat(path, &st) != 0)
 836   {
 837     log_error("failed to stat '%s': %d (%s)", path, errno, strerror(errno));
 838     free(path);
 839     return false;
 840   }
 841
 842   g_studio.name = cmd_ptr->studio_name;
 843   cmd_ptr->studio_name = NULL;
 844
 845   g_studio.filename = path;
 846
 847   if (!jack_reset_all_params())
 848   {
 849     log_error("jack_reset_all_params() failed");
 850     return false;
 851   }
 852
 853   fd = open(path, O_RDONLY);
 854   if (fd == -1)
 855   {
 856     log_error("failed to open '%s': %d (%s)", path, errno, strerror(errno));
 857     return false;
 858   }
 859
 860   parser = XML_ParserCreate(NULL);
 861   if (parser == NULL)
 862   {
 863     log_error("XML_ParserCreate() failed to create parser object.");
 864     close(fd);
 865     return false;
 866   }
 867
 868   //log_info("conf file size is %llu bytes", (unsigned long long)st.st_size);
 869
 870   /* we are expecting that conf file has small enough size to fit in memory */
 871
 872   buffer = XML_GetBuffer(parser, st.st_size);
 873   if (buffer == NULL)
 874   {
 875     log_error("XML_GetBuffer() failed.");
 876     XML_ParserFree(parser);
 877     close(fd);
 878     return false;
 879   }
 880
 881   bytes_read = read(fd, buffer, st.st_size);
 882   if (bytes_read != st.st_size)
 883   {
 884     log_error("read() returned unexpected result.");
 885     XML_ParserFree(parser);
 886     close(fd);
 887     return false;
 888   }
 889
 890   parse_context.error = XML_FALSE;
 891   parse_context.depth = -1;
 892   parse_context.str = NULL;
 893   parse_context.client = NULL;
 894   parse_context.port = NULL;
 895   parse_context.dict = NULL;
 896   parse_context.room = NULL;
 897
 898   XML_SetElementHandler(parser, callback_elstart, callback_elend);
 899   XML_SetCharacterDataHandler(parser, callback_chrdata);
 900   XML_SetUserData(parser, &parse_context);
 901
 902   if (!ladish_studio_show())
 903   {
 904     log_error("ladish_studio_show() failed.");
 905     XML_ParserFree(parser);
 906     close(fd);
 907     return false;
 908   }
 909
 910   xmls = XML_ParseBuffer(parser, bytes_read, XML_TRUE);
 911   if (xmls == XML_STATUS_ERROR)
 912   {
 913     if (!parse_context.error)
 914     {
 915       log_error("XML_ParseBuffer() failed.");
 916     }
 917
 918     ladish_notify_simple(LADISH_NOTIFY_URGENCY_HIGH, "Studio load failed", "Please inspect the ladishd log (~/.ladish/ladish.log) for more info");
 919     ladish_studio_clear();
 920     XML_ParserFree(parser);
 921     close(fd);
 922     return false;
 923   }
 924
 925   XML_ParserFree(parser);
 926   close(fd);
 927
 928   if (parse_context.error)
 929   {
 930     ladish_studio_clear();
 931     ladish_notify_simple(LADISH_NOTIFY_URGENCY_HIGH, "Studio load failed", "Please inspect the ladishd log (~/.ladish/ladish.log) for more info");
 932     return false;
 933   }
 934
 935   ladish_interlink_clients(ladish_studio_get_studio_graph(), ladish_studio_get_studio_app_supervisor());
 936
 937   g_studio.persisted = true;
 938   log_info("Studio loaded. ('%s')", path);
 939
 940   ladish_graph_dump(g_studio.jack_graph);
 941   ladish_graph_dump(g_studio.studio_graph);
 942
 943   ladish_studio_announce();
 944
 945   cmd_ptr->command.state = LADISH_COMMAND_STATE_DONE;
 946   return true;
 947 }
 948
 949 static void destructor(void * command_context)
 950 {
 951   log_info("load studio command destructor");
 952   if (cmd_ptr->studio_name != NULL)
 953   {
 954     free(cmd_ptr->studio_name);
 955   }
 956 }
 957
 958 #undef cmd_ptr
 959
 960 bool ladish_command_load_studio(void * call_ptr, struct ladish_cqueue * queue_ptr, const char * studio_name, bool autostart)
 961 {
 962   struct ladish_command_load_studio * cmd_ptr;
 963   char * studio_name_dup;
 964
 965   studio_name_dup = strdup(studio_name);
 966   if (studio_name_dup == NULL)
 967   {
 968     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup('%s') failed.", studio_name);
 969     goto fail;
 970   }
 971
 972   if (!ladish_command_unload_studio(call_ptr, queue_ptr))
 973   {
 974     goto fail_free_name;
 975   }
 976
 977   cmd_ptr = ladish_command_new(sizeof(struct ladish_command_load_studio));
 978   if (cmd_ptr == NULL)
 979   {
 980     log_error("ladish_command_new() failed.");
 981     goto fail_drop_unload_command;
 982   }
 983
 984   cmd_ptr->command.run = run;
 985   cmd_ptr->command.destructor = destructor;
 986   cmd_ptr->studio_name = studio_name_dup;
 987
 988   if (!ladish_cqueue_add_command(queue_ptr, &cmd_ptr->command))
 989   {
 990     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "ladish_cqueue_add_command() failed.");
 991     goto fail_destroy_command;
 992   }
 993
 994   if (autostart)
 995   {
 996     if (!ladish_command_start_studio(call_ptr, queue_ptr))
 997     {
 998       goto fail_drop_load_command;
 999     }
1000   }
1001
1002   return true;
1003
1004 fail_drop_load_command:
1005   ladish_cqueue_drop_command(queue_ptr);
1006
1007 fail_destroy_command:
1008   free(cmd_ptr);
1009
1010 fail_drop_unload_command:
1011   ladish_cqueue_drop_command(queue_ptr);
1012
1013 fail_free_name:
1014   free(studio_name_dup);
1015
1016 fail:
1017   return false;
1018 }