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